Home | History | Annotate | Download | only in views 
      1 // Copyright (c) 2012 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 "ui/app_list/views/app_list_view.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/command_line.h"
     10 #include "base/strings/string_util.h"
     11 #include "base/win/windows_version.h"
     12 #include "ui/app_list/app_list_constants.h"
     13 #include "ui/app_list/app_list_model.h"
     14 #include "ui/app_list/app_list_view_delegate.h"
     15 #include "ui/app_list/speech_ui_model.h"
     16 #include "ui/app_list/views/app_list_background.h"
     17 #include "ui/app_list/views/app_list_folder_view.h"
     18 #include "ui/app_list/views/app_list_main_view.h"
     19 #include "ui/app_list/views/app_list_view_observer.h"
     20 #include "ui/app_list/views/apps_container_view.h"
     21 #include "ui/app_list/views/contents_view.h"
     22 #include "ui/app_list/views/search_box_view.h"
     23 #include "ui/app_list/views/speech_view.h"
     24 #include "ui/base/ui_base_switches.h"
     25 #include "ui/compositor/layer.h"
     26 #include "ui/compositor/layer_animation_observer.h"
     27 #include "ui/compositor/scoped_layer_animation_settings.h"
     28 #include "ui/gfx/image/image_skia.h"
     29 #include "ui/gfx/insets.h"
     30 #include "ui/gfx/path.h"
     31 #include "ui/gfx/skia_util.h"
     32 #include "ui/views/bubble/bubble_frame_view.h"
     33 #include "ui/views/controls/textfield/textfield.h"
     34 #include "ui/views/layout/fill_layout.h"
     35 #include "ui/views/widget/widget.h"
     36 
     37 #if defined(USE_AURA)
     38 #include "ui/aura/window.h"
     39 #include "ui/aura/window_tree_host.h"
     40 #include "ui/views/bubble/bubble_window_targeter.h"
     41 #if defined(OS_WIN)
     42 #include "ui/base/win/shell.h"
     43 #endif
     44 #if !defined(OS_CHROMEOS)
     45 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
     46 #endif
     47 #endif  // defined(USE_AURA)
     48 
     49 namespace app_list {
     50 
     51 namespace {
     52 
     53 // The margin from the edge to the speech UI.
     54 const int kSpeechUIMargin = 12;
     55 
     56 // The vertical position for the appearing animation of the speech UI.
     57 const float kSpeechUIAppearingPosition = 12;
     58 
     59 // The distance between the arrow tip and edge of the anchor view.
     60 const int kArrowOffset = 10;
     61 
     62 // Determines whether the current environment supports shadows bubble borders.
     63 bool SupportsShadow() {
     64 #if defined(OS_WIN)
     65   // Shadows are not supported on Windows without Aero Glass.
     66   if (!ui::win::IsAeroGlassEnabled() ||
     67       CommandLine::ForCurrentProcess()->HasSwitch(
     68           switches::kDisableDwmComposition)) {
     69     return false;
     70   }
     71 #elif defined(OS_LINUX) && !defined(OS_CHROMEOS)
     72   // Shadows are not supported on (non-ChromeOS) Linux.
     73   return false;
     74 #endif
     75   return true;
     76 }
     77 
     78 }  // namespace
     79 
     80 // An animation observer to hide the view at the end of the animation.
     81 class HideViewAnimationObserver : public ui::ImplicitAnimationObserver {
     82  public:
     83   HideViewAnimationObserver()
     84       : frame_(NULL),
     85         target_(NULL) {
     86   }
     87 
     88   virtual ~HideViewAnimationObserver() {
     89     if (target_)
     90       StopObservingImplicitAnimations();
     91   }
     92 
     93   void SetTarget(views::View* target) {
     94     if (!target_)
     95       StopObservingImplicitAnimations();
     96     target_ = target;
     97   }
     98 
     99   void set_frame(views::BubbleFrameView* frame) { frame_ = frame; }
    100 
    101  private:
    102   // Overridden from ui::ImplicitAnimationObserver:
    103   virtual void OnImplicitAnimationsCompleted() OVERRIDE {
    104     if (target_) {
    105       target_->SetVisible(false);
    106       target_ = NULL;
    107 
    108       // Should update the background by invoking SchedulePaint().
    109       frame_->SchedulePaint();
    110     }
    111   }
    112 
    113   views::BubbleFrameView* frame_;
    114   views::View* target_;
    115 
    116   DISALLOW_COPY_AND_ASSIGN(HideViewAnimationObserver);
    117 };
    118 
    119 ////////////////////////////////////////////////////////////////////////////////
    120 // AppListView:
    121 
    122 AppListView::AppListView(AppListViewDelegate* delegate)
    123     : delegate_(delegate),
    124       app_list_main_view_(NULL),
    125       speech_view_(NULL),
    126       animation_observer_(new HideViewAnimationObserver()) {
    127   CHECK(delegate);
    128 
    129   delegate_->AddObserver(this);
    130   delegate_->GetSpeechUI()->AddObserver(this);
    131 }
    132 
    133 AppListView::~AppListView() {
    134   delegate_->GetSpeechUI()->RemoveObserver(this);
    135   delegate_->RemoveObserver(this);
    136   animation_observer_.reset();
    137   // Remove child views first to ensure no remaining dependencies on delegate_.
    138   RemoveAllChildViews(true);
    139 }
    140 
    141 void AppListView::InitAsBubbleAttachedToAnchor(
    142     gfx::NativeView parent,
    143     int initial_apps_page,
    144     views::View* anchor,
    145     const gfx::Vector2d& anchor_offset,
    146     views::BubbleBorder::Arrow arrow,
    147     bool border_accepts_events) {
    148   SetAnchorView(anchor);
    149   InitAsBubbleInternal(
    150       parent, initial_apps_page, arrow, border_accepts_events, anchor_offset);
    151 }
    152 
    153 void AppListView::InitAsBubbleAtFixedLocation(
    154     gfx::NativeView parent,
    155     int initial_apps_page,
    156     const gfx::Point& anchor_point_in_screen,
    157     views::BubbleBorder::Arrow arrow,
    158     bool border_accepts_events) {
    159   SetAnchorView(NULL);
    160   SetAnchorRect(gfx::Rect(anchor_point_in_screen, gfx::Size()));
    161   InitAsBubbleInternal(
    162       parent, initial_apps_page, arrow, border_accepts_events, gfx::Vector2d());
    163 }
    164 
    165 void AppListView::SetBubbleArrow(views::BubbleBorder::Arrow arrow) {
    166   GetBubbleFrameView()->bubble_border()->set_arrow(arrow);
    167   SizeToContents();  // Recalcuates with new border.
    168   GetBubbleFrameView()->SchedulePaint();
    169 }
    170 
    171 void AppListView::SetAnchorPoint(const gfx::Point& anchor_point) {
    172   SetAnchorRect(gfx::Rect(anchor_point, gfx::Size()));
    173 }
    174 
    175 void AppListView::SetDragAndDropHostOfCurrentAppList(
    176     ApplicationDragAndDropHost* drag_and_drop_host) {
    177   app_list_main_view_->SetDragAndDropHostOfCurrentAppList(drag_and_drop_host);
    178 }
    179 
    180 void AppListView::ShowWhenReady() {
    181   app_list_main_view_->ShowAppListWhenReady();
    182 }
    183 
    184 void AppListView::Close() {
    185   app_list_main_view_->Close();
    186   delegate_->Dismiss();
    187 }
    188 
    189 void AppListView::UpdateBounds() {
    190   SizeToContents();
    191 }
    192 
    193 bool AppListView::ShouldCenterWindow() const {
    194   return delegate_->ShouldCenterWindow();
    195 }
    196 
    197 gfx::Size AppListView::GetPreferredSize() const {
    198   return app_list_main_view_->GetPreferredSize();
    199 }
    200 
    201 void AppListView::Paint(gfx::Canvas* canvas, const views::CullSet& cull_set) {
    202   views::BubbleDelegateView::Paint(canvas, cull_set);
    203   if (!next_paint_callback_.is_null()) {
    204     next_paint_callback_.Run();
    205     next_paint_callback_.Reset();
    206   }
    207 }
    208 
    209 void AppListView::OnThemeChanged() {
    210 #if defined(OS_WIN)
    211   GetWidget()->Close();
    212 #endif
    213 }
    214 
    215 bool AppListView::ShouldHandleSystemCommands() const {
    216   return true;
    217 }
    218 
    219 void AppListView::Prerender() {
    220   app_list_main_view_->Prerender();
    221 }
    222 
    223 void AppListView::OnProfilesChanged() {
    224   app_list_main_view_->search_box_view()->InvalidateMenu();
    225 }
    226 
    227 void AppListView::SetProfileByPath(const base::FilePath& profile_path) {
    228   delegate_->SetProfileByPath(profile_path);
    229   app_list_main_view_->ModelChanged();
    230 }
    231 
    232 void AppListView::AddObserver(AppListViewObserver* observer) {
    233   observers_.AddObserver(observer);
    234 }
    235 
    236 void AppListView::RemoveObserver(AppListViewObserver* observer) {
    237   observers_.RemoveObserver(observer);
    238 }
    239 
    240 // static
    241 void AppListView::SetNextPaintCallback(const base::Closure& callback) {
    242   next_paint_callback_ = callback;
    243 }
    244 
    245 #if defined(OS_WIN)
    246 HWND AppListView::GetHWND() const {
    247   gfx::NativeWindow window =
    248       GetWidget()->GetTopLevelWidget()->GetNativeWindow();
    249   return window->GetHost()->GetAcceleratedWidget();
    250 }
    251 #endif
    252 
    253 PaginationModel* AppListView::GetAppsPaginationModel() {
    254   return app_list_main_view_->contents_view()
    255       ->apps_container_view()
    256       ->apps_grid_view()
    257       ->pagination_model();
    258 }
    259 
    260 void AppListView::InitAsBubbleInternal(gfx::NativeView parent,
    261                                        int initial_apps_page,
    262                                        views::BubbleBorder::Arrow arrow,
    263                                        bool border_accepts_events,
    264                                        const gfx::Vector2d& anchor_offset) {
    265   app_list_main_view_ =
    266       new AppListMainView(delegate_.get(), initial_apps_page, parent);
    267   AddChildView(app_list_main_view_);
    268   app_list_main_view_->SetPaintToLayer(true);
    269   app_list_main_view_->SetFillsBoundsOpaquely(false);
    270   app_list_main_view_->layer()->SetMasksToBounds(true);
    271 
    272   // Speech recognition is available only when the start page exists.
    273   if (delegate_ && delegate_->IsSpeechRecognitionEnabled()) {
    274     speech_view_ = new SpeechView(delegate_.get());
    275     speech_view_->SetVisible(false);
    276     speech_view_->SetPaintToLayer(true);
    277     speech_view_->SetFillsBoundsOpaquely(false);
    278     speech_view_->layer()->SetOpacity(0.0f);
    279     AddChildView(speech_view_);
    280   }
    281 
    282   OnProfilesChanged();
    283   set_color(kContentsBackgroundColor);
    284   set_margins(gfx::Insets());
    285   set_parent_window(parent);
    286   set_close_on_deactivate(false);
    287   set_close_on_esc(false);
    288   set_anchor_view_insets(gfx::Insets(kArrowOffset + anchor_offset.y(),
    289                                      kArrowOffset + anchor_offset.x(),
    290                                      kArrowOffset - anchor_offset.y(),
    291                                      kArrowOffset - anchor_offset.x()));
    292   set_border_accepts_events(border_accepts_events);
    293   set_shadow(SupportsShadow() ? views::BubbleBorder::BIG_SHADOW
    294                               : views::BubbleBorder::NO_SHADOW_OPAQUE_BORDER);
    295   views::BubbleDelegateView::CreateBubble(this);
    296   SetBubbleArrow(arrow);
    297 
    298 #if defined(USE_AURA)
    299   aura::Window* window = GetWidget()->GetNativeWindow();
    300   window->layer()->SetMasksToBounds(true);
    301   GetBubbleFrameView()->set_background(new AppListBackground(
    302       GetBubbleFrameView()->bubble_border()->GetBorderCornerRadius(),
    303       app_list_main_view_));
    304   set_background(NULL);
    305   window->SetEventTargeter(scoped_ptr<ui::EventTargeter>(
    306       new views::BubbleWindowTargeter(this)));
    307 #else
    308   set_background(new AppListBackground(
    309       GetBubbleFrameView()->bubble_border()->GetBorderCornerRadius(),
    310       app_list_main_view_));
    311 
    312   // On non-aura the bubble has two widgets, and it's possible for the border
    313   // to be shown independently in odd situations. Explicitly hide the bubble
    314   // widget to ensure that any WM_WINDOWPOSCHANGED messages triggered by the
    315   // window manager do not have the SWP_SHOWWINDOW flag set which would cause
    316   // the border to be shown. See http://crbug.com/231687 .
    317   GetWidget()->Hide();
    318 #endif
    319 
    320   if (delegate_)
    321     delegate_->ViewInitialized();
    322 }
    323 
    324 void AppListView::OnBeforeBubbleWidgetInit(
    325     views::Widget::InitParams* params,
    326     views::Widget* widget) const {
    327 #if defined(USE_AURA) && !defined(OS_CHROMEOS)
    328   if (delegate_ && delegate_->ForceNativeDesktop())
    329     params->native_widget = new views::DesktopNativeWidgetAura(widget);
    330 #endif
    331 #if defined(OS_WIN)
    332   // Windows 7 and higher offer pinning to the taskbar, but we need presence
    333   // on the taskbar for the user to be able to pin us. So, show the window on
    334   // the taskbar for these versions of Windows.
    335   if (base::win::GetVersion() >= base::win::VERSION_WIN7)
    336     params->force_show_in_taskbar = true;
    337 #elif defined(OS_LINUX)
    338   // Set up a custom WM_CLASS for the app launcher window. This allows task
    339   // switchers in X11 environments to distinguish it from main browser windows.
    340   params->wm_class_name = kAppListWMClass;
    341   // Show the window in the taskbar, even though it is a bubble, which would not
    342   // normally be shown.
    343   params->force_show_in_taskbar = true;
    344 #endif
    345 }
    346 
    347 views::View* AppListView::GetInitiallyFocusedView() {
    348   return app_list_main_view_->search_box_view()->search_box();
    349 }
    350 
    351 gfx::ImageSkia AppListView::GetWindowIcon() {
    352   if (delegate_)
    353     return delegate_->GetWindowIcon();
    354 
    355   return gfx::ImageSkia();
    356 }
    357 
    358 bool AppListView::WidgetHasHitTestMask() const {
    359   return true;
    360 }
    361 
    362 void AppListView::GetWidgetHitTestMask(gfx::Path* mask) const {
    363   DCHECK(mask);
    364   mask->addRect(gfx::RectToSkRect(
    365       GetBubbleFrameView()->GetContentsBounds()));
    366 }
    367 
    368 bool AppListView::AcceleratorPressed(const ui::Accelerator& accelerator) {
    369   // The accelerator is added by BubbleDelegateView.
    370   if (accelerator.key_code() == ui::VKEY_ESCAPE) {
    371     if (app_list_main_view_->search_box_view()->HasSearch()) {
    372       app_list_main_view_->search_box_view()->ClearSearch();
    373     } else if (app_list_main_view_->contents_view()
    374                    ->apps_container_view()
    375                    ->IsInFolderView()) {
    376       app_list_main_view_->contents_view()
    377           ->apps_container_view()
    378           ->app_list_folder_view()
    379           ->CloseFolderPage();
    380       return true;
    381     } else {
    382       GetWidget()->Deactivate();
    383       Close();
    384     }
    385     return true;
    386   }
    387 
    388   return false;
    389 }
    390 
    391 void AppListView::Layout() {
    392   const gfx::Rect contents_bounds = GetContentsBounds();
    393   app_list_main_view_->SetBoundsRect(contents_bounds);
    394 
    395   if (speech_view_) {
    396     gfx::Rect speech_bounds = contents_bounds;
    397     int preferred_height = speech_view_->GetPreferredSize().height();
    398     speech_bounds.Inset(kSpeechUIMargin, kSpeechUIMargin);
    399     speech_bounds.set_height(std::min(speech_bounds.height(),
    400                                       preferred_height));
    401     speech_bounds.Inset(-speech_view_->GetInsets());
    402     speech_view_->SetBoundsRect(speech_bounds);
    403   }
    404 }
    405 
    406 void AppListView::SchedulePaintInRect(const gfx::Rect& rect) {
    407   BubbleDelegateView::SchedulePaintInRect(rect);
    408   if (GetBubbleFrameView())
    409     GetBubbleFrameView()->SchedulePaint();
    410 }
    411 
    412 void AppListView::OnWidgetDestroying(views::Widget* widget) {
    413   BubbleDelegateView::OnWidgetDestroying(widget);
    414   if (delegate_ && widget == GetWidget())
    415     delegate_->ViewClosing();
    416 }
    417 
    418 void AppListView::OnWidgetActivationChanged(views::Widget* widget,
    419                                             bool active) {
    420   // Do not called inherited function as the bubble delegate auto close
    421   // functionality is not used.
    422   if (widget == GetWidget())
    423     FOR_EACH_OBSERVER(AppListViewObserver, observers_,
    424                       OnActivationChanged(widget, active));
    425 }
    426 
    427 void AppListView::OnWidgetVisibilityChanged(views::Widget* widget,
    428                                             bool visible) {
    429   BubbleDelegateView::OnWidgetVisibilityChanged(widget, visible);
    430 
    431   if (widget != GetWidget())
    432     return;
    433 
    434   if (!visible)
    435     app_list_main_view_->ResetForShow();
    436 }
    437 
    438 void AppListView::OnSpeechRecognitionStateChanged(
    439     SpeechRecognitionState new_state) {
    440   if (!speech_view_)
    441     return;
    442 
    443   bool will_appear = (new_state == SPEECH_RECOGNITION_RECOGNIZING ||
    444                       new_state == SPEECH_RECOGNITION_IN_SPEECH ||
    445                       new_state == SPEECH_RECOGNITION_NETWORK_ERROR);
    446   // No change for this class.
    447   if (speech_view_->visible() == will_appear)
    448     return;
    449 
    450   if (will_appear)
    451     speech_view_->Reset();
    452 
    453   animation_observer_->set_frame(GetBubbleFrameView());
    454   gfx::Transform speech_transform;
    455   speech_transform.Translate(
    456       0, SkFloatToMScalar(kSpeechUIAppearingPosition));
    457   if (will_appear)
    458     speech_view_->layer()->SetTransform(speech_transform);
    459 
    460   {
    461     ui::ScopedLayerAnimationSettings main_settings(
    462         app_list_main_view_->layer()->GetAnimator());
    463     if (will_appear) {
    464       animation_observer_->SetTarget(app_list_main_view_);
    465       main_settings.AddObserver(animation_observer_.get());
    466     }
    467     app_list_main_view_->layer()->SetOpacity(will_appear ? 0.0f : 1.0f);
    468   }
    469 
    470   {
    471     ui::ScopedLayerAnimationSettings speech_settings(
    472         speech_view_->layer()->GetAnimator());
    473     if (!will_appear) {
    474       animation_observer_->SetTarget(speech_view_);
    475       speech_settings.AddObserver(animation_observer_.get());
    476     }
    477 
    478     speech_view_->layer()->SetOpacity(will_appear ? 1.0f : 0.0f);
    479     if (will_appear)
    480       speech_view_->layer()->SetTransform(gfx::Transform());
    481     else
    482       speech_view_->layer()->SetTransform(speech_transform);
    483   }
    484 
    485   if (will_appear)
    486     speech_view_->SetVisible(true);
    487   else
    488     app_list_main_view_->SetVisible(true);
    489 }
    490 
    491 }  // namespace app_list
    492