| // 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/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 "base/memory/weak_ptr.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/compositor/closure_animation_observer.h" |
| #include "ui/compositor/scoped_layer_animation_settings.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 kHomeCardHeight = 100; |
| const int kHomeCardMinimizedHeight = 6; |
| |
| gfx::Rect GetBoundsForState(const gfx::Rect& screen_bounds, |
| HomeCard::State state) { |
| switch (state) { |
| case HomeCard::HIDDEN: |
| break; |
| |
| case HomeCard::VISIBLE_CENTERED: |
| return screen_bounds; |
| |
| case HomeCard::VISIBLE_BOTTOM: |
| return gfx::Rect(0, |
| screen_bounds.bottom() - kHomeCardHeight, |
| screen_bounds.width(), |
| kHomeCardHeight); |
| case HomeCard::VISIBLE_MINIMIZED: |
| return gfx::Rect(0, |
| screen_bounds.bottom() - kHomeCardMinimizedHeight, |
| screen_bounds.width(), |
| kHomeCardMinimizedHeight); |
| } |
| |
| NOTREACHED(); |
| return gfx::Rect(); |
| } |
| |
| // Makes sure the homecard is center-aligned horizontally and bottom-aligned |
| // vertically. |
| class HomeCardLayoutManager : public aura::LayoutManager { |
| public: |
| class Delegate { |
| public: |
| virtual ~Delegate() {} |
| |
| virtual HomeCard::State GetState() = 0; |
| virtual aura::Window* GetNativeWindow() = 0; |
| }; |
| |
| explicit HomeCardLayoutManager(Delegate* delegate) |
| : delegate_(delegate) {} |
| |
| virtual ~HomeCardLayoutManager() {} |
| |
| void Layout() { |
| aura::Window* home_card = delegate_->GetNativeWindow(); |
| // |home_card| could be detached from the root window (e.g. when it is being |
| // destroyed). |
| if (!home_card || !home_card->GetRootWindow()) |
| return; |
| |
| { |
| ui::ScopedLayerAnimationSettings settings( |
| home_card->layer()->GetAnimator()); |
| settings.SetTweenType(gfx::Tween::EASE_IN_OUT); |
| SetChildBoundsDirect(home_card, GetBoundsForState( |
| home_card->GetRootWindow()->bounds(), delegate_->GetState())); |
| } |
| } |
| |
| 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, requested_bounds); |
| } |
| |
| Delegate* delegate_; |
| |
| DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager); |
| }; |
| |
| class HomeCardGestureManager { |
| public: |
| class Delegate { |
| public: |
| // Called when the gesture has ended. The state of the home card will |
| // end up with |final_state|. |
| virtual void OnGestureEnded(HomeCard::State final_state) = 0; |
| |
| // Called when the gesture position is updated so that |delegate| should |
| // update the visual. The arguments represent the state of the current |
| // gesture position is switching from |from_state| to |to_state|, and |
| // the level of the progress is at |progress|, which is 0 to 1. |
| // |from_state| and |to_state| could be same. For example, if the user moves |
| // the finger down to the bottom of the screen, both states are MINIMIZED. |
| // In that case |progress| is 0. |
| virtual void OnGestureProgressed( |
| HomeCard::State from_state, |
| HomeCard::State to_state, |
| float progress) = 0; |
| }; |
| |
| HomeCardGestureManager(Delegate* delegate, |
| const gfx::Rect& screen_bounds) |
| : delegate_(delegate), |
| last_state_(HomeCard::Get()->GetState()), |
| y_offset_(0), |
| last_estimated_top_(0), |
| screen_bounds_(screen_bounds) {} |
| |
| void ProcessGestureEvent(ui::GestureEvent* event) { |
| switch (event->type()) { |
| case ui::ET_GESTURE_SCROLL_BEGIN: |
| y_offset_ = event->location().y(); |
| event->SetHandled(); |
| break; |
| case ui::ET_GESTURE_SCROLL_END: |
| event->SetHandled(); |
| delegate_->OnGestureEnded(GetClosestState()); |
| break; |
| case ui::ET_GESTURE_SCROLL_UPDATE: |
| UpdateScrollState(*event); |
| break; |
| case ui::ET_SCROLL_FLING_START: { |
| const ui::GestureEventDetails& details = event->details(); |
| const float kFlingCompletionVelocity = 100.0f; |
| if (::fabs(details.velocity_y()) > kFlingCompletionVelocity) { |
| int step = (details.velocity_y() > 0) ? 1 : -1; |
| int new_state = static_cast<int>(last_state_) + step; |
| if (new_state >= HomeCard::VISIBLE_CENTERED && |
| new_state <= HomeCard::VISIBLE_MINIMIZED) { |
| last_state_ = static_cast<HomeCard::State>(new_state); |
| } |
| delegate_->OnGestureEnded(last_state_); |
| } |
| break; |
| } |
| default: |
| // do nothing. |
| break; |
| } |
| } |
| |
| private: |
| HomeCard::State GetClosestState() { |
| // The top position of the bounds for one smaller state than the current |
| // one. |
| int smaller_top = -1; |
| for (int i = HomeCard::VISIBLE_MINIMIZED; |
| i >= HomeCard::VISIBLE_CENTERED; --i) { |
| HomeCard::State state = static_cast<HomeCard::State>(i); |
| int top = GetBoundsForState(screen_bounds_, state).y(); |
| if (last_estimated_top_ == top) { |
| return state; |
| } else if (last_estimated_top_ > top) { |
| if (smaller_top < 0) |
| return state; |
| |
| if (smaller_top - last_estimated_top_ > (smaller_top - top) / 5) { |
| return state; |
| } else { |
| return static_cast<HomeCard::State>(i + 1); |
| } |
| } |
| smaller_top = top; |
| } |
| |
| NOTREACHED(); |
| return last_state_; |
| } |
| |
| void UpdateScrollState(const ui::GestureEvent& event) { |
| last_estimated_top_ = event.root_location().y() - y_offset_; |
| |
| // The bounds which is at one smaller state than the current one. |
| gfx::Rect smaller_bounds; |
| |
| for (int i = HomeCard::VISIBLE_MINIMIZED; |
| i >= HomeCard::VISIBLE_CENTERED; --i) { |
| HomeCard::State state = static_cast<HomeCard::State>(i); |
| const gfx::Rect bounds = GetBoundsForState(screen_bounds_, state); |
| if (last_estimated_top_ == bounds.y()) { |
| delegate_->OnGestureProgressed(last_state_, state, 1.0f); |
| last_state_ = state; |
| return; |
| } else if (last_estimated_top_ > bounds.y()) { |
| if (smaller_bounds.IsEmpty()) { |
| // Smaller than minimized -- returning the minimized bounds. |
| delegate_->OnGestureProgressed(last_state_, state, 1.0f); |
| } else { |
| // The finger is between two states. |
| float progress = |
| static_cast<float>((smaller_bounds.y() - last_estimated_top_)) / |
| (smaller_bounds.y() - bounds.y()); |
| if (last_state_ == state) { |
| if (event.details().scroll_y() > 0) { |
| state = static_cast<HomeCard::State>(state + 1); |
| progress = 1.0f - progress; |
| } else { |
| last_state_ = static_cast<HomeCard::State>(last_state_ + 1); |
| } |
| } |
| delegate_->OnGestureProgressed(last_state_, state, progress); |
| } |
| last_state_ = state; |
| return; |
| } |
| smaller_bounds = bounds; |
| } |
| NOTREACHED(); |
| } |
| |
| Delegate* delegate_; |
| HomeCard::State last_state_; |
| |
| // The offset from the top edge of the home card and the initial position of |
| // gesture. |
| int y_offset_; |
| |
| // The estimated top edge of the home card after the last touch event. |
| int last_estimated_top_; |
| |
| // The bounds of the screen to compute the home card bounds. |
| gfx::Rect screen_bounds_; |
| |
| 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), |
| weak_factory_(this) { |
| bottom_view_ = new AthenaStartPageView(view_delegate); |
| AddChildView(bottom_view_); |
| bottom_view_->SetPaintToLayer(true); |
| bottom_view_->layer()->SetFillsBoundsOpaquely(false); |
| |
| 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); |
| 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); |
| 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 SetStateWithAnimation(HomeCard::State from_state, |
| HomeCard::State to_state) { |
| if ((from_state == HomeCard::VISIBLE_MINIMIZED && |
| to_state == HomeCard::VISIBLE_BOTTOM) || |
| (from_state == HomeCard::VISIBLE_BOTTOM && |
| to_state == HomeCard::VISIBLE_MINIMIZED)) { |
| minimized_view_->SetVisible(true); |
| bottom_view_->SetVisible(true); |
| { |
| ui::ScopedLayerAnimationSettings settings( |
| minimized_view_->layer()->GetAnimator()); |
| settings.SetTweenType(gfx::Tween::EASE_IN_OUT); |
| settings.AddObserver(new ui::ClosureAnimationObserver( |
| base::Bind(&HomeCardView::SetState, |
| weak_factory_.GetWeakPtr(), |
| to_state))); |
| minimized_view_->layer()->SetOpacity( |
| (to_state == HomeCard::VISIBLE_MINIMIZED) ? 1.0f : 0.0f); |
| } |
| } else { |
| // TODO(mukai): Take care of other transition. |
| SetState(to_state); |
| } |
| } |
| |
| 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()) { |
| if (child == minimized_view_) { |
| gfx::Rect minimized_bounds = bounds(); |
| minimized_bounds.set_y( |
| minimized_bounds.bottom() - kHomeCardMinimizedHeight); |
| minimized_bounds.set_height(kHomeCardMinimizedHeight); |
| child->SetBoundsRect(minimized_bounds); |
| } else { |
| child->SetBoundsRect(bounds()); |
| } |
| } |
| } |
| } |
| 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: |
| // views::WidgetDelegate: |
| virtual views::View* GetContentsView() OVERRIDE { |
| return this; |
| } |
| |
| app_list::AppListMainView* main_view_; |
| views::View* bottom_view_; |
| views::View* minimized_view_; |
| scoped_ptr<HomeCardGestureManager> gesture_manager_; |
| HomeCardGestureManager::Delegate* gesture_delegate_; |
| base::WeakPtrFactory<HomeCardView> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(HomeCardView); |
| }; |
| |
| class HomeCardImpl : public HomeCard, |
| public AcceleratorHandler, |
| public HomeCardLayoutManager::Delegate, |
| public HomeCardGestureManager::Delegate, |
| public WindowManagerObserver, |
| public aura::client::ActivationChangeObserver { |
| public: |
| explicit HomeCardImpl(AppModelBuilder* model_builder); |
| virtual ~HomeCardImpl(); |
| |
| void Init(); |
| |
| private: |
| enum Command { |
| COMMAND_SHOW_HOME_CARD, |
| }; |
| void InstallAccelerators(); |
| |
| // Overridden from HomeCard: |
| virtual void SetState(State state) OVERRIDE; |
| virtual State GetState() OVERRIDE; |
| virtual void RegisterSearchProvider( |
| app_list::SearchProvider* search_provider) OVERRIDE; |
| virtual void UpdateVirtualKeyboardBounds( |
| const gfx::Rect& bounds) OVERRIDE; |
| |
| // AcceleratorHandler: |
| virtual bool IsCommandEnabled(int command_id) const OVERRIDE { return true; } |
| virtual bool OnAcceleratorFired(int command_id, |
| const ui::Accelerator& accelerator) OVERRIDE; |
| |
| // HomeCardLayoutManager::Delegate: |
| virtual aura::Window* GetNativeWindow() OVERRIDE; |
| |
| // HomeCardGestureManager::Delegate: |
| virtual void OnGestureEnded(State final_state) OVERRIDE; |
| virtual void OnGestureProgressed( |
| State from_state, State to_state, float progress) OVERRIDE; |
| |
| // WindowManagerObserver: |
| virtual void OnOverviewModeEnter() OVERRIDE; |
| virtual void OnOverviewModeExit() OVERRIDE; |
| |
| // aura::client::ActivationChangeObserver: |
| virtual void OnWindowActivated(aura::Window* gained_active, |
| aura::Window* lost_active) OVERRIDE; |
| |
| scoped_ptr<AppModelBuilder> model_builder_; |
| |
| HomeCard::State state_; |
| |
| // original_state_ is the state which the home card should go back to after |
| // the virtual keyboard is hidden. |
| HomeCard::State original_state_; |
| |
| views::Widget* home_card_widget_; |
| HomeCardView* home_card_view_; |
| scoped_ptr<AppListViewDelegate> view_delegate_; |
| HomeCardLayoutManager* layout_manager_; |
| aura::client::ActivationClient* activation_client_; // Not owned |
| |
| // 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), |
| original_state_(VISIBLE_MINIMIZED), |
| home_card_widget_(NULL), |
| home_card_view_(NULL), |
| layout_manager_(NULL), |
| activation_client_(NULL) { |
| DCHECK(!instance); |
| instance = this; |
| WindowManager::GetInstance()->AddObserver(this); |
| } |
| |
| HomeCardImpl::~HomeCardImpl() { |
| DCHECK(instance); |
| WindowManager::GetInstance()->RemoveObserver(this); |
| if (activation_client_) |
| activation_client_->RemoveObserver(this); |
| home_card_widget_->CloseNow(); |
| instance = NULL; |
| } |
| |
| void HomeCardImpl::Init() { |
| InstallAccelerators(); |
| ScreenManager::ContainerParams params("HomeCardContainer", CP_HOME_CARD); |
| params.can_activate_children = true; |
| aura::Window* container = ScreenManager::Get()->CreateContainer(params); |
| layout_manager_ = new HomeCardLayoutManager(this); |
| |
| container->SetLayoutManager(layout_manager_); |
| wm::SetChildWindowVisibilityChangesAnimated(container); |
| |
| view_delegate_.reset(new AppListViewDelegate(model_builder_.get())); |
| if (search_provider_) |
| view_delegate_->RegisterSearchProvider(search_provider_.get()); |
| |
| home_card_view_ = new HomeCardView(view_delegate_.get(), container, this); |
| home_card_widget_ = new views::Widget(); |
| views::Widget::InitParams widget_params( |
| views::Widget::InitParams::TYPE_WINDOW_FRAMELESS); |
| widget_params.parent = container; |
| widget_params.delegate = home_card_view_; |
| widget_params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW; |
| home_card_widget_->Init(widget_params); |
| |
| SetState(VISIBLE_MINIMIZED); |
| home_card_view_->Layout(); |
| |
| activation_client_ = |
| aura::client::GetActivationClient(container->GetRootWindow()); |
| if (activation_client_) |
| activation_client_->AddObserver(this); |
| } |
| |
| 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); |
| } |
| |
| void HomeCardImpl::SetState(HomeCard::State state) { |
| if (state_ == state) |
| return; |
| |
| // Update |state_| before changing the visibility of the widgets, so that |
| // LayoutManager callbacks get the correct state. |
| HomeCard::State old_state = state_; |
| state_ = state; |
| original_state_ = state; |
| if (state_ == HIDDEN) { |
| home_card_widget_->Hide(); |
| } else { |
| if (state_ == VISIBLE_CENTERED) |
| home_card_widget_->Show(); |
| else |
| home_card_widget_->ShowInactive(); |
| home_card_view_->SetStateWithAnimation(old_state, state); |
| layout_manager_->Layout(); |
| } |
| } |
| |
| HomeCard::State HomeCardImpl::GetState() { |
| return state_; |
| } |
| |
| 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 && !bounds.IsEmpty()) { |
| SetState(HIDDEN); |
| original_state_ = VISIBLE_MINIMIZED; |
| } else if (state_ == VISIBLE_BOTTOM && !bounds.IsEmpty()) { |
| SetState(VISIBLE_CENTERED); |
| original_state_ = VISIBLE_BOTTOM; |
| } else if (state_ != original_state_ && bounds.IsEmpty()) { |
| SetState(original_state_); |
| } |
| } |
| |
| bool HomeCardImpl::OnAcceleratorFired(int command_id, |
| const ui::Accelerator& accelerator) { |
| DCHECK_EQ(COMMAND_SHOW_HOME_CARD, command_id); |
| |
| if (state_ == VISIBLE_CENTERED && original_state_ != VISIBLE_BOTTOM) |
| SetState(VISIBLE_MINIMIZED); |
| else if (state_ == VISIBLE_MINIMIZED) |
| SetState(VISIBLE_CENTERED); |
| return true; |
| } |
| |
| aura::Window* HomeCardImpl::GetNativeWindow() { |
| if (state_ == HIDDEN) |
| return NULL; |
| |
| return home_card_widget_ ? home_card_widget_->GetNativeWindow() : NULL; |
| } |
| |
| void HomeCardImpl::OnGestureEnded(State final_state) { |
| home_card_view_->ClearGesture(); |
| if (state_ != final_state && |
| (state_ == VISIBLE_MINIMIZED || final_state == VISIBLE_MINIMIZED)) { |
| WindowManager::GetInstance()->ToggleOverview(); |
| } else { |
| HomeCard::State old_state = state_; |
| state_ = final_state; |
| home_card_view_->SetStateWithAnimation(old_state, final_state); |
| layout_manager_->Layout(); |
| } |
| } |
| |
| void HomeCardImpl::OnGestureProgressed( |
| State from_state, State to_state, float progress) { |
| 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. |
| } |
| |
| void HomeCardImpl::OnOverviewModeEnter() { |
| SetState(VISIBLE_BOTTOM); |
| } |
| |
| void HomeCardImpl::OnOverviewModeExit() { |
| SetState(VISIBLE_MINIMIZED); |
| } |
| |
| void HomeCardImpl::OnWindowActivated(aura::Window* gained_active, |
| aura::Window* lost_active) { |
| if (state_ != HIDDEN && |
| gained_active != home_card_widget_->GetNativeWindow()) { |
| SetState(VISIBLE_MINIMIZED); |
| } |
| } |
| |
| } // namespace |
| |
| // static |
| HomeCard* HomeCard::Create(AppModelBuilder* model_builder) { |
| (new HomeCardImpl(model_builder))->Init(); |
| DCHECK(instance); |
| return instance; |
| } |
| |
| // static |
| void HomeCard::Shutdown() { |
| DCHECK(instance); |
| delete instance; |
| instance = NULL; |
| } |
| |
| // static |
| HomeCard* HomeCard::Get() { |
| DCHECK(instance); |
| return instance; |
| } |
| |
| } // namespace athena |