Home | History | Annotate | Download | only in home 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "athena/home/home_card_impl.h"
      6 
      7 #include <cmath>
      8 #include <limits>
      9 
     10 #include "athena/env/public/athena_env.h"
     11 #include "athena/home/app_list_view_delegate.h"
     12 #include "athena/home/athena_start_page_view.h"
     13 #include "athena/home/home_card_constants.h"
     14 #include "athena/home/minimized_home.h"
     15 #include "athena/home/public/app_model_builder.h"
     16 #include "athena/screen/public/screen_manager.h"
     17 #include "athena/util/container_priorities.h"
     18 #include "athena/wm/public/window_manager.h"
     19 #include "ui/app_list/search_provider.h"
     20 #include "ui/app_list/views/app_list_main_view.h"
     21 #include "ui/app_list/views/contents_view.h"
     22 #include "ui/aura/layout_manager.h"
     23 #include "ui/aura/window.h"
     24 #include "ui/compositor/layer.h"
     25 #include "ui/compositor/scoped_layer_animation_settings.h"
     26 #include "ui/gfx/animation/tween.h"
     27 #include "ui/views/layout/fill_layout.h"
     28 #include "ui/views/widget/widget.h"
     29 #include "ui/views/widget/widget_delegate.h"
     30 #include "ui/wm/core/shadow_types.h"
     31 #include "ui/wm/core/visibility_controller.h"
     32 #include "ui/wm/public/activation_client.h"
     33 
     34 namespace athena {
     35 namespace {
     36 
     37 HomeCard* instance = NULL;
     38 
     39 gfx::Rect GetBoundsForState(const gfx::Rect& screen_bounds,
     40                             HomeCard::State state) {
     41   switch (state) {
     42     case HomeCard::HIDDEN:
     43       break;
     44 
     45     case HomeCard::VISIBLE_CENTERED:
     46       return screen_bounds;
     47 
     48     // Do not change the home_card's size, only changes the top position
     49     // instead, because size change causes unnecessary re-layouts.
     50     case HomeCard::VISIBLE_BOTTOM:
     51       return gfx::Rect(0,
     52                        screen_bounds.bottom() - kHomeCardHeight,
     53                        screen_bounds.width(),
     54                        screen_bounds.height());
     55     case HomeCard::VISIBLE_MINIMIZED:
     56       return gfx::Rect(0,
     57                        screen_bounds.bottom() - kHomeCardMinimizedHeight,
     58                        screen_bounds.width(),
     59                        screen_bounds.height());
     60   }
     61 
     62   NOTREACHED();
     63   return gfx::Rect();
     64 }
     65 
     66 }  // namespace
     67 
     68 // Makes sure the homecard is center-aligned horizontally and bottom-aligned
     69 // vertically.
     70 class HomeCardLayoutManager : public aura::LayoutManager {
     71  public:
     72   HomeCardLayoutManager()
     73       : home_card_(NULL),
     74         minimized_layer_(NULL) {}
     75 
     76   virtual ~HomeCardLayoutManager() {}
     77 
     78   void Layout(bool animate, gfx::Tween::Type tween_type) {
     79     // |home_card| could be detached from the root window (e.g. when it is being
     80     // destroyed).
     81     if (!home_card_ || !home_card_->IsVisible() || !home_card_->GetRootWindow())
     82       return;
     83 
     84     scoped_ptr<ui::ScopedLayerAnimationSettings> settings;
     85     if (animate) {
     86       settings.reset(new ui::ScopedLayerAnimationSettings(
     87           home_card_->layer()->GetAnimator()));
     88       settings->SetTweenType(tween_type);
     89     }
     90     SetChildBoundsDirect(home_card_, GetBoundsForState(
     91         home_card_->GetRootWindow()->bounds(), HomeCard::Get()->GetState()));
     92   }
     93 
     94   void SetMinimizedLayer(ui::Layer* minimized_layer) {
     95     minimized_layer_ = minimized_layer;
     96     UpdateMinimizedHomeBounds();
     97   }
     98 
     99  private:
    100   void UpdateMinimizedHomeBounds() {
    101     gfx::Rect minimized_bounds = minimized_layer_->parent()->bounds();
    102     minimized_bounds.set_y(
    103         minimized_bounds.bottom() - kHomeCardMinimizedHeight);
    104     minimized_bounds.set_height(kHomeCardMinimizedHeight);
    105     minimized_layer_->SetBounds(minimized_bounds);
    106   }
    107 
    108   // aura::LayoutManager:
    109   virtual void OnWindowResized() OVERRIDE {
    110     Layout(false, gfx::Tween::LINEAR);
    111     UpdateMinimizedHomeBounds();
    112   }
    113   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
    114     if (!home_card_) {
    115       home_card_ = child;
    116       Layout(false, gfx::Tween::LINEAR);
    117     }
    118   }
    119   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {
    120     if (home_card_ == child)
    121       home_card_ = NULL;
    122   }
    123   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
    124   }
    125   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
    126                                               bool visible) OVERRIDE {
    127     if (home_card_ == child)
    128       Layout(false, gfx::Tween::LINEAR);
    129   }
    130   virtual void SetChildBounds(aura::Window* child,
    131                               const gfx::Rect& requested_bounds) OVERRIDE {
    132     SetChildBoundsDirect(child, requested_bounds);
    133   }
    134 
    135   aura::Window* home_card_;
    136   ui::Layer* minimized_layer_;
    137 
    138   DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager);
    139 };
    140 
    141 // The container view of home card contents of each state.
    142 class HomeCardView : public views::WidgetDelegateView {
    143  public:
    144   HomeCardView(app_list::AppListViewDelegate* view_delegate,
    145                aura::Window* container,
    146                HomeCardGestureManager::Delegate* gesture_delegate)
    147       : gesture_delegate_(gesture_delegate) {
    148     SetLayoutManager(new views::FillLayout());
    149     // Ideally AppListMainView should be used here and have AthenaStartPageView
    150     // as its child view, so that custom pages and apps grid are available in
    151     // the home card.
    152     // TODO(mukai): make it so after the detailed UI has been fixed.
    153     main_view_ = new AthenaStartPageView(view_delegate);
    154     AddChildView(main_view_);
    155   }
    156 
    157   void SetStateProgress(HomeCard::State from_state,
    158                         HomeCard::State to_state,
    159                         float progress) {
    160     // TODO(mukai): not clear the focus, but simply close the virtual keyboard.
    161     GetFocusManager()->ClearFocus();
    162     if (from_state == HomeCard::VISIBLE_CENTERED)
    163       main_view_->SetLayoutState(1.0f - progress);
    164     else if (to_state == HomeCard::VISIBLE_CENTERED)
    165       main_view_->SetLayoutState(progress);
    166     UpdateShadow(true);
    167   }
    168 
    169   void SetStateWithAnimation(HomeCard::State state,
    170                              gfx::Tween::Type tween_type) {
    171     UpdateShadow(state != HomeCard::VISIBLE_MINIMIZED);
    172     if (state == HomeCard::VISIBLE_CENTERED)
    173       main_view_->RequestFocusOnSearchBox();
    174     else
    175       GetWidget()->GetFocusManager()->ClearFocus();
    176 
    177     main_view_->SetLayoutStateWithAnimation(
    178         (state == HomeCard::VISIBLE_CENTERED) ? 1.0f : 0.0f, tween_type);
    179   }
    180 
    181   void ClearGesture() {
    182     gesture_manager_.reset();
    183   }
    184 
    185   // views::View:
    186   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
    187     if (!gesture_manager_ &&
    188         event->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
    189       gesture_manager_.reset(new HomeCardGestureManager(
    190           gesture_delegate_,
    191           GetWidget()->GetNativeWindow()->GetRootWindow()->bounds()));
    192     }
    193 
    194     if (gesture_manager_)
    195       gesture_manager_->ProcessGestureEvent(event);
    196   }
    197   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE {
    198     if (HomeCard::Get()->GetState() == HomeCard::VISIBLE_MINIMIZED &&
    199         event.IsLeftMouseButton() && event.GetClickCount() == 1) {
    200       athena::WindowManager::Get()->ToggleOverview();
    201       return true;
    202     }
    203     return false;
    204   }
    205 
    206  private:
    207   void UpdateShadow(bool should_show) {
    208     wm::SetShadowType(
    209         GetWidget()->GetNativeWindow(),
    210         should_show ? wm::SHADOW_TYPE_RECTANGULAR : wm::SHADOW_TYPE_NONE);
    211   }
    212 
    213   // views::WidgetDelegate:
    214   virtual views::View* GetContentsView() OVERRIDE {
    215     return this;
    216   }
    217 
    218   AthenaStartPageView* main_view_;
    219   scoped_ptr<HomeCardGestureManager> gesture_manager_;
    220   HomeCardGestureManager::Delegate* gesture_delegate_;
    221 
    222   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
    223 };
    224 
    225 HomeCardImpl::HomeCardImpl(AppModelBuilder* model_builder)
    226     : model_builder_(model_builder),
    227       state_(HIDDEN),
    228       original_state_(VISIBLE_MINIMIZED),
    229       home_card_widget_(NULL),
    230       home_card_view_(NULL),
    231       layout_manager_(NULL),
    232       activation_client_(NULL) {
    233   DCHECK(!instance);
    234   instance = this;
    235   WindowManager::Get()->AddObserver(this);
    236 }
    237 
    238 HomeCardImpl::~HomeCardImpl() {
    239   DCHECK(instance);
    240   WindowManager::Get()->RemoveObserver(this);
    241   if (activation_client_)
    242     activation_client_->RemoveObserver(this);
    243   home_card_widget_->CloseNow();
    244 
    245   // Reset the view delegate first as it access search provider during
    246   // shutdown.
    247   view_delegate_.reset();
    248   search_provider_.reset();
    249   instance = NULL;
    250 }
    251 
    252 void HomeCardImpl::Init() {
    253   InstallAccelerators();
    254   ScreenManager::ContainerParams params("HomeCardContainer", CP_HOME_CARD);
    255   params.can_activate_children = true;
    256   aura::Window* container = ScreenManager::Get()->CreateContainer(params);
    257   layout_manager_ = new HomeCardLayoutManager();
    258 
    259   container->SetLayoutManager(layout_manager_);
    260   wm::SetChildWindowVisibilityChangesAnimated(container);
    261 
    262   view_delegate_.reset(new AppListViewDelegate(model_builder_.get()));
    263   if (search_provider_)
    264     view_delegate_->RegisterSearchProvider(search_provider_.get());
    265 
    266   home_card_view_ = new HomeCardView(view_delegate_.get(), container, this);
    267   home_card_widget_ = new views::Widget();
    268   views::Widget::InitParams widget_params(
    269       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
    270   widget_params.parent = container;
    271   widget_params.delegate = home_card_view_;
    272   widget_params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
    273   home_card_widget_->Init(widget_params);
    274 
    275   minimized_home_ = CreateMinimizedHome();
    276   container->layer()->Add(minimized_home_->layer());
    277   container->layer()->StackAtTop(minimized_home_->layer());
    278   layout_manager_->SetMinimizedLayer(minimized_home_->layer());
    279 
    280   SetState(VISIBLE_MINIMIZED);
    281   home_card_view_->Layout();
    282 
    283   activation_client_ =
    284       aura::client::GetActivationClient(container->GetRootWindow());
    285   if (activation_client_)
    286     activation_client_->AddObserver(this);
    287 
    288   AthenaEnv::Get()->SetDisplayWorkAreaInsets(
    289       gfx::Insets(0, 0, kHomeCardMinimizedHeight, 0));
    290 }
    291 
    292 aura::Window* HomeCardImpl::GetHomeCardWindowForTest() const {
    293   return home_card_widget_ ? home_card_widget_->GetNativeWindow() : NULL;
    294 }
    295 
    296 void HomeCardImpl::InstallAccelerators() {
    297   const AcceleratorData accelerator_data[] = {
    298       {TRIGGER_ON_PRESS, ui::VKEY_L, ui::EF_CONTROL_DOWN,
    299        COMMAND_SHOW_HOME_CARD, AF_NONE},
    300   };
    301   AcceleratorManager::Get()->RegisterAccelerators(
    302       accelerator_data, arraysize(accelerator_data), this);
    303 }
    304 
    305 void HomeCardImpl::SetState(HomeCard::State state) {
    306   if (state_ == state)
    307     return;
    308 
    309   // Update |state_| before changing the visibility of the widgets, so that
    310   // LayoutManager callbacks get the correct state.
    311   HomeCard::State old_state = state_;
    312   state_ = state;
    313   original_state_ = state;
    314 
    315   if (old_state == VISIBLE_MINIMIZED ||
    316       state_ == VISIBLE_MINIMIZED) {
    317     minimized_home_->layer()->SetVisible(true);
    318     {
    319       ui::ScopedLayerAnimationSettings settings(
    320           minimized_home_->layer()->GetAnimator());
    321       minimized_home_->layer()->SetVisible(state_ == VISIBLE_MINIMIZED);
    322       minimized_home_->layer()->SetOpacity(
    323           state_ == VISIBLE_MINIMIZED ? 1.0f : 0.0f);
    324     }
    325   }
    326   if (state_ == HIDDEN) {
    327     home_card_widget_->Hide();
    328   } else {
    329     if (state_ == VISIBLE_MINIMIZED)
    330       home_card_widget_->ShowInactive();
    331     else
    332       home_card_widget_->Show();
    333     home_card_view_->SetStateWithAnimation(state, gfx::Tween::EASE_IN_OUT);
    334     layout_manager_->Layout(true, gfx::Tween::EASE_IN_OUT);
    335   }
    336 }
    337 
    338 HomeCard::State HomeCardImpl::GetState() {
    339   return state_;
    340 }
    341 
    342 void HomeCardImpl::RegisterSearchProvider(
    343     app_list::SearchProvider* search_provider) {
    344   DCHECK(!search_provider_);
    345   search_provider_.reset(search_provider);
    346   view_delegate_->RegisterSearchProvider(search_provider_.get());
    347 }
    348 
    349 void HomeCardImpl::UpdateVirtualKeyboardBounds(
    350     const gfx::Rect& bounds) {
    351   if (state_ == VISIBLE_MINIMIZED && !bounds.IsEmpty()) {
    352     SetState(HIDDEN);
    353     original_state_ = VISIBLE_MINIMIZED;
    354   } else if (state_ == VISIBLE_BOTTOM && !bounds.IsEmpty()) {
    355     SetState(VISIBLE_CENTERED);
    356     original_state_ = VISIBLE_BOTTOM;
    357   } else if (state_ != original_state_ && bounds.IsEmpty()) {
    358     SetState(original_state_);
    359   }
    360 }
    361 
    362 bool HomeCardImpl::IsCommandEnabled(int command_id) const {
    363   return true;
    364 }
    365 
    366 bool HomeCardImpl::OnAcceleratorFired(int command_id,
    367                                       const ui::Accelerator& accelerator) {
    368   DCHECK_EQ(COMMAND_SHOW_HOME_CARD, command_id);
    369 
    370   if (state_ == VISIBLE_CENTERED && original_state_ != VISIBLE_BOTTOM)
    371     SetState(VISIBLE_MINIMIZED);
    372   else if (state_ == VISIBLE_MINIMIZED)
    373     SetState(VISIBLE_CENTERED);
    374   return true;
    375 }
    376 
    377 void HomeCardImpl::OnGestureEnded(State final_state, bool is_fling) {
    378   home_card_view_->ClearGesture();
    379   if (state_ != final_state &&
    380       (state_ == VISIBLE_MINIMIZED || final_state == VISIBLE_MINIMIZED)) {
    381     SetState(final_state);
    382     WindowManager::Get()->ToggleOverview();
    383   } else {
    384     state_ = final_state;
    385     // When the animation happens after a fling, EASE_IN_OUT would cause weird
    386     // slow-down right after the finger release because of slow-in. Therefore
    387     // EASE_OUT is better.
    388     gfx::Tween::Type tween_type =
    389         is_fling ? gfx::Tween::EASE_OUT : gfx::Tween::EASE_IN_OUT;
    390     home_card_view_->SetStateWithAnimation(state_, tween_type);
    391     layout_manager_->Layout(true, tween_type);
    392   }
    393 }
    394 
    395 void HomeCardImpl::OnGestureProgressed(
    396     State from_state, State to_state, float progress) {
    397   if (from_state == VISIBLE_MINIMIZED || to_state == VISIBLE_MINIMIZED) {
    398     minimized_home_->layer()->SetVisible(true);
    399     float opacity =
    400         (from_state == VISIBLE_MINIMIZED) ? 1.0f - progress : progress;
    401     minimized_home_->layer()->SetOpacity(opacity);
    402   }
    403   gfx::Rect screen_bounds =
    404       home_card_widget_->GetNativeWindow()->GetRootWindow()->bounds();
    405   home_card_widget_->SetBounds(gfx::Tween::RectValueBetween(
    406       progress,
    407       GetBoundsForState(screen_bounds, from_state),
    408       GetBoundsForState(screen_bounds, to_state)));
    409 
    410   home_card_view_->SetStateProgress(from_state, to_state, progress);
    411 
    412   // TODO(mukai): signals the update to the window manager so that it shows the
    413   // intermediate visual state of overview mode.
    414 }
    415 
    416 void HomeCardImpl::OnOverviewModeEnter() {
    417   if (state_ == HIDDEN || state_ == VISIBLE_MINIMIZED)
    418     SetState(VISIBLE_BOTTOM);
    419 }
    420 
    421 void HomeCardImpl::OnOverviewModeExit() {
    422   SetState(VISIBLE_MINIMIZED);
    423 }
    424 
    425 void HomeCardImpl::OnSplitViewModeEnter() {
    426 }
    427 
    428 void HomeCardImpl::OnSplitViewModeExit() {
    429 }
    430 
    431 void HomeCardImpl::OnWindowActivated(aura::Window* gained_active,
    432                                      aura::Window* lost_active) {
    433   if (state_ != HIDDEN &&
    434       gained_active != home_card_widget_->GetNativeWindow()) {
    435     SetState(VISIBLE_MINIMIZED);
    436   }
    437 }
    438 
    439 // static
    440 HomeCard* HomeCard::Create(AppModelBuilder* model_builder) {
    441   (new HomeCardImpl(model_builder))->Init();
    442   DCHECK(instance);
    443   return instance;
    444 }
    445 
    446 // static
    447 void HomeCard::Shutdown() {
    448   DCHECK(instance);
    449   delete instance;
    450   instance = NULL;
    451 }
    452 
    453 // static
    454 HomeCard* HomeCard::Get() {
    455   DCHECK(instance);
    456   return instance;
    457 }
    458 
    459 }  // namespace athena
    460