Minimize HomeCard if the user opens something in 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 <limits>
 
 #include "athena/home/app_list_view_delegate.h"
 #include "athena/home/bottom_home_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/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;
 
 // Makes sure the homecard is center-aligned horizontally and bottom-aligned
 // vertically.
 class HomeCardLayoutManager : public aura::LayoutManager {
  public:
@@ skipping 107 matching lines @@
   BottomHomeView* bottom_view_;
   views::View* minimized_view_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
 };
 
 class HomeCardImpl : public HomeCard,
                      public AcceleratorHandler,
                      public HomeCardLayoutManager::Delegate,
                      public MinimizedHomeDragDelegate,
-                     public WindowManagerObserver {
+                     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 {
     DCHECK_EQ(COMMAND_SHOW_HOME_CARD, command_id);
@@ skipping 44 matching lines @@
 
   // WindowManagerObserver:
   virtual void OnOverviewModeEnter() OVERRIDE {
     SetState(VISIBLE_BOTTOM);
   }
 
   virtual void OnOverviewModeExit() OVERRIDE {
     SetState(VISIBLE_MINIMIZED);
   }
 
+  // aura::client::ActivationChangeObserver:
+  virtual void OnWindowActivated(aura::Window* gained_active,
+                                 aura::Window* lost_active) OVERRIDE {
+    if (gained_active != home_card_widget_->GetNativeWindow())
+      SetState(VISIBLE_MINIMIZED);
+  }
+
   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_(VISIBLE_MINIMIZED),
+      state_(HIDDEN),
       original_state_(VISIBLE_MINIMIZED),
       home_card_widget_(NULL),
       home_card_view_(NULL),
-      layout_manager_(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::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.
   state_ = state;
   original_state_ = state;
   if (state_ == HIDDEN) {
     home_card_widget_->Hide();
   } else {
     home_card_widget_->Show();
     home_card_view_->SetState(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()) {
@@ skipping 25 matching lines @@
   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);
 }
@@ skipping 14 matching lines @@
   instance = NULL;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena