Redesign the home card bottom state.

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 <cmath>
 #include <limits>
 
 #include "athena/common/container_priorities.h"
 #include "athena/home/app_list_view_delegate.h"
-#include "athena/home/bottom_home_view.h"
+#include "athena/home/athena_start_page_view.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 "athena/wm/public/window_manager_observer.h"
 #include "base/bind.h"
 #include "ui/app_list/search_provider.h"
 #include "ui/app_list/views/app_list_main_view.h"
 #include "ui/app_list/views/contents_view.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_animations.h"
 #include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace athena {
 namespace {
 
 HomeCard* instance = NULL;
+const int kHomeCardMinimizedHeight = 8;
 
 gfx::Rect GetBoundsForState(const gfx::Rect& screen_bounds,
                             HomeCard::State state) {
-  const int kHomeCardHeight = 150;
+  const int kHomeCardHeight = 100;
   const int kHomeCardMinimizedHeight = 8;

[sadrul, 2014/08/13 22:01:13]

Did you mean to remove this?

The small text in the mock says the blackbar is 6px high, with the white-bar 2px
high, 112px wide, bottom-aligned.

[Jun Mukai, 2014/08/13 23:18:23]

thanks, removed. Also changed the height to 6px. Let me redesign the blackbar in
another CL.

 
   switch (state) {
     case HomeCard::HIDDEN:
       break;
 
     case HomeCard::VISIBLE_CENTERED:
       return screen_bounds;
 
     case HomeCard::VISIBLE_BOTTOM:
       return gfx::Rect(0,
@@ skipping 208 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(HomeCardGestureManager);
 };
 
 // The container view of home card contents of each state.
 class HomeCardView : public views::WidgetDelegateView {
  public:
   HomeCardView(app_list::AppListViewDelegate* view_delegate,
                aura::Window* container,
                HomeCardGestureManager::Delegate* gesture_delegate)
       : gesture_delegate_(gesture_delegate) {
-    bottom_view_ = new BottomHomeView(view_delegate);
+    bottom_view_ = new AthenaStartPageView(view_delegate);
     AddChildView(bottom_view_);
+    bottom_view_->SetPaintToLayer(true);
 
     main_view_ = new app_list::AppListMainView(
         view_delegate, 0 /* initial_apps_page */, container);
     AddChildView(main_view_);
     main_view_->set_background(
         views::Background::CreateSolidBackground(SK_ColorWHITE));
+    main_view_->SetPaintToLayer(true);
 
     minimized_view_ = CreateMinimizedHome();
+    minimized_view_->SetPaintToLayer(true);

[sadrul, 2014/08/13 22:01:13]

I agree with the comment in the CL description: this would be easier to do with
a single View with different states, instead of having separate main_view_ and
bottom_view_ (|bottom_view_| would have to stay, since it remains in-place, and
fades out when the bottom/main-view comes up.

[Jun Mukai, 2014/08/13 23:18:23]

Thanks. I think we should keep minimized_view_ as a separate view because it
will overlap with bottom view in the transition.

     AddChildView(minimized_view_);
   }
 
+  void SetStateProgress(HomeCard::State from_state,
+                        HomeCard::State to_state,
+                        float progress) {
+    if (from_state == HomeCard::VISIBLE_BOTTOM &&
+        to_state == HomeCard::VISIBLE_MINIMIZED) {
+      SetStateProgress(to_state, from_state, 1.0 - progress);
+      return;
+    }
+
+    // View from minimized to bottom.
+    if (from_state == HomeCard::VISIBLE_MINIMIZED &&
+        to_state == HomeCard::VISIBLE_BOTTOM) {
+      bottom_view_->SetVisible(true);
+      minimized_view_->SetVisible(true);
+      minimized_view_->layer()->SetOpacity(1.0f - progress);

[sadrul, 2014/08/13 22:01:13]

When transitioning MINIMIZED ==> BOTTOM, with progress == 0, shouldn't the
opacity of |minimized_view_| be 0 (i.e. == progress)? (I think the opacity of
bottom_view_ will be = (1 - progress) instead)

[Jun Mukai, 2014/08/13 23:18:23]

The progress means how far from |from_state_|, so progress 0 means same as the
|from_state_|, which is MINIMIZED state in this case. So the opacity should be
1.0.

+      return;
+    }
+
+    SetState(to_state);
+  }
+
   void SetState(HomeCard::State state) {
     bottom_view_->SetVisible(state == HomeCard::VISIBLE_BOTTOM);
     main_view_->SetVisible(state == HomeCard::VISIBLE_CENTERED);
     minimized_view_->SetVisible(state == HomeCard::VISIBLE_MINIMIZED);
+    if (minimized_view_->visible())
+      minimized_view_->layer()->SetOpacity(1.0f);
     if (state == HomeCard::VISIBLE_CENTERED) {
       app_list::ContentsView* contents_view = main_view_->contents_view();
       contents_view->SetActivePage(contents_view->GetPageIndexForNamedPage(
           app_list::ContentsView::NAMED_PAGE_START));
     }
     wm::SetShadowType(GetWidget()->GetNativeView(),
                       state == HomeCard::VISIBLE_MINIMIZED ?
                       wm::SHADOW_TYPE_NONE :
                       wm::SHADOW_TYPE_RECTANGULAR);
   }
 
   void ClearGesture() {
     gesture_manager_.reset();
   }
 
   // views::View:
   virtual void Layout() OVERRIDE {
     for (int i = 0; i < child_count(); ++i) {
       views::View* child = child_at(i);
       if (child->visible()) {
-        child->SetBoundsRect(bounds());
-        return;
+        if (child == minimized_view_) {
+          gfx::Rect minimized_bounds = bounds();
+          minimized_bounds.set_y(
+              minimized_bounds.bottom() - kHomeCardMinimizedHeight);
+          child->SetBoundsRect(minimized_bounds);
+        } else {
+          child->SetBoundsRect(bounds());
+        }
       }
     }
-
-    // One of the child views has to be visible.
-    NOTREACHED();
   }
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
     if (!gesture_manager_ &&
         event->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       gesture_manager_.reset(new HomeCardGestureManager(
           gesture_delegate_,
           GetWidget()->GetNativeWindow()->GetRootWindow()->bounds()));
     }
 
     if (gesture_manager_)
       gesture_manager_->ProcessGestureEvent(event);
   }
 
  private:
   virtual views::View* GetContentsView() OVERRIDE {
     return this;
   }
 
   app_list::AppListMainView* main_view_;
-  BottomHomeView* bottom_view_;
+  views::View* bottom_view_;
   views::View* minimized_view_;
   scoped_ptr<HomeCardGestureManager> gesture_manager_;
   HomeCardGestureManager::Delegate* gesture_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
 };
 
 class HomeCardImpl : public HomeCard,
                      public AcceleratorHandler,
                      public HomeCardLayoutManager::Delegate,
@@ skipping 194 matching lines @@
     WindowManager::GetInstance()->ToggleOverview();
   } else {
     state_ = final_state;
     home_card_view_->SetState(final_state);
     layout_manager_->Layout();
   }
 }
 
 void HomeCardImpl::OnGestureProgressed(
     State from_state, State to_state, float progress) {
-  // Do not update |state_| but update the look of home_card_view.
-  // TODO(mukai): allow mixed visual of |from_state| and |to_state|.
-  home_card_view_->SetState(to_state);
+  home_card_view_->SetStateProgress(from_state, to_state, progress);
 
   gfx::Rect screen_bounds =
       home_card_widget_->GetNativeWindow()->GetRootWindow()->bounds();
   home_card_widget_->SetBounds(gfx::Tween::RectValueBetween(
       progress,
       GetBoundsForState(screen_bounds, from_state),
       GetBoundsForState(screen_bounds, to_state)));
 
   // TODO(mukai): signals the update to the window manager so that it shows the
   // intermediate visual state of overview mode.
@@ skipping 31 matching lines @@
   instance = NULL;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena