ash/frame/custom_frame_view_ash.cc

   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 "ash/frame/custom_frame_view_ash.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "ash/ash_switches.h"
  11 #include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
  12 #include "ash/frame/default_header_painter.h"
  13 #include "ash/frame/frame_border_hit_test_controller.h"
  14 #include "ash/frame/frame_util.h"
  15 #include "ash/frame/header_painter.h"
  16 #include "ash/session/session_state_delegate.h"
  17 #include "ash/shell.h"
  18 #include "ash/shell_observer.h"
  19 #include "ash/wm/immersive_fullscreen_controller.h"
  20 #include "ash/wm/window_state.h"
  21 #include "ash/wm/window_state_delegate.h"
  22 #include "ash/wm/window_state_observer.h"
  23 #include "base/command_line.h"
  24 #include "ui/aura/client/aura_constants.h"
  25 #include "ui/aura/window.h"
  26 #include "ui/aura/window_observer.h"
  27 #include "ui/gfx/canvas.h"
  28 #include "ui/gfx/image/image.h"
  29 #include "ui/gfx/rect.h"
  30 #include "ui/gfx/rect_conversions.h"
  31 #include "ui/gfx/size.h"
  32 #include "ui/views/controls/image_view.h"
  33 #include "ui/views/view.h"
  34 #include "ui/views/view_targeter.h"
  35 #include "ui/views/widget/widget.h"
  36 #include "ui/views/widget/widget_delegate.h"
  37
  38 namespace {
  39
  40 ///////////////////////////////////////////////////////////////////////////////
  41 // CustomFrameViewAshWindowStateDelegate
  42
  43 // Handles a user's fullscreen request (Shift+F4/F4). Puts the window into
  44 // immersive fullscreen if immersive fullscreen is enabled for non-browser
  45 // windows.
  46 class CustomFrameViewAshWindowStateDelegate
  47     : public ash::wm::WindowStateDelegate,
  48       public ash::wm::WindowStateObserver,
  49       public aura::WindowObserver {
  50  public:
  51   CustomFrameViewAshWindowStateDelegate(
  52       ash::wm::WindowState* window_state,
  53       ash::CustomFrameViewAsh* custom_frame_view)
  54       : window_state_(NULL) {
  55     immersive_fullscreen_controller_.reset(
  56         new ash::ImmersiveFullscreenController);
  57     custom_frame_view->InitImmersiveFullscreenControllerForView(
  58         immersive_fullscreen_controller_.get());
  59
  60     // Add a window state observer to exit fullscreen properly in case
  61     // fullscreen is exited without going through
  62     // WindowState::ToggleFullscreen(). This is the case when exiting
  63     // immersive fullscreen via the "Restore" window control.
  64     // TODO(pkotwicz): This is a hack. Remove ASAP. http://crbug.com/319048
  65     window_state_ = window_state;
  66     window_state_->AddObserver(this);
  67     window_state_->window()->AddObserver(this);
  68   }
  69   virtual ~CustomFrameViewAshWindowStateDelegate() {
  70     if (window_state_) {
  71       window_state_->RemoveObserver(this);
  72       window_state_->window()->RemoveObserver(this);
  73     }
  74   }
  75  private:
  76   // Overridden from ash::wm::WindowStateDelegate:
  77   virtual bool ToggleFullscreen(ash::wm::WindowState* window_state) OVERRIDE {
  78     bool enter_fullscreen = !window_state->IsFullscreen();
  79     if (enter_fullscreen) {
  80       window_state->window()->SetProperty(aura::client::kShowStateKey,
  81                                            ui::SHOW_STATE_FULLSCREEN);
  82     } else {
  83       window_state->Restore();
  84     }
  85     if (immersive_fullscreen_controller_) {
  86       immersive_fullscreen_controller_->SetEnabled(
  87           ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
  88           enter_fullscreen);
  89     }
  90     return true;
  91   }
  92   // Overridden from aura::WindowObserver:
  93   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
  94     window_state_->RemoveObserver(this);
  95     window_state_->window()->RemoveObserver(this);
  96     window_state_ = NULL;
  97   }
  98   // Overridden from ash::wm::WindowStateObserver:
  99   virtual void OnPostWindowStateTypeChange(
 100       ash::wm::WindowState* window_state,
 101       ash::wm::WindowStateType old_type) OVERRIDE {
 102     if (!window_state->IsFullscreen() &&
 103         !window_state->IsMinimized() &&
 104         immersive_fullscreen_controller_.get() &&
 105         immersive_fullscreen_controller_->IsEnabled()) {
 106       immersive_fullscreen_controller_->SetEnabled(
 107           ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
 108           false);
 109     }
 110   }
 111
 112   ash::wm::WindowState* window_state_;
 113   scoped_ptr<ash::ImmersiveFullscreenController>
 114       immersive_fullscreen_controller_;
 115
 116   DISALLOW_COPY_AND_ASSIGN(CustomFrameViewAshWindowStateDelegate);
 117 };
 118
 119 }  // namespace
 120
 121 namespace ash {
 122
 123 ///////////////////////////////////////////////////////////////////////////////
 124 // CustomFrameViewAsh::HeaderView
 125
 126 // View which paints the header. It slides off and on screen in immersive
 127 // fullscreen.
 128 class CustomFrameViewAsh::HeaderView
 129     : public views::View,
 130       public ImmersiveFullscreenController::Delegate,
 131       public ShellObserver {
 132  public:
 133   // |frame| is the widget that the caption buttons act on.
 134   explicit HeaderView(views::Widget* frame);
 135   virtual ~HeaderView();
 136
 137   // Schedules a repaint for the entire title.
 138   void SchedulePaintForTitle();
 139
 140   // Tells the window controls to reset themselves to the normal state.
 141   void ResetWindowControls();
 142
 143   // Returns the amount of the view's pixels which should be on screen.
 144   int GetPreferredOnScreenHeight() const;
 145
 146   // Returns the view's preferred height.
 147   int GetPreferredHeight() const;
 148
 149   // Returns the view's minimum width.
 150   int GetMinimumWidth() const;
 151
 152   void UpdateAvatarIcon();
 153
 154   // views::View:
 155   virtual void Layout() OVERRIDE;
 156   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 157   virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE;
 158
 159   // ShellObserver:
 160   virtual void OnMaximizeModeStarted() OVERRIDE;
 161   virtual void OnMaximizeModeEnded() OVERRIDE;
 162
 163   FrameCaptionButtonContainerView* caption_button_container() {
 164     return caption_button_container_;
 165   }
 166
 167   views::View* avatar_icon() const {
 168     return avatar_icon_;
 169   }
 170
 171  private:
 172   // ImmersiveFullscreenController::Delegate:
 173   virtual void OnImmersiveRevealStarted() OVERRIDE;
 174   virtual void OnImmersiveRevealEnded() OVERRIDE;
 175   virtual void OnImmersiveFullscreenExited() OVERRIDE;
 176   virtual void SetVisibleFraction(double visible_fraction) OVERRIDE;
 177   virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() const OVERRIDE;
 178
 179   // The widget that the caption buttons act on.
 180   views::Widget* frame_;
 181
 182   // Helper for painting the header.
 183   scoped_ptr<DefaultHeaderPainter> header_painter_;
 184
 185   views::ImageView* avatar_icon_;
 186
 187   // View which contains the window caption buttons.
 188   FrameCaptionButtonContainerView* caption_button_container_;
 189
 190   // The fraction of the header's height which is visible while in fullscreen.
 191   // This value is meaningless when not in fullscreen.
 192   double fullscreen_visible_fraction_;
 193
 194   DISALLOW_COPY_AND_ASSIGN(HeaderView);
 195 };
 196
 197 CustomFrameViewAsh::HeaderView::HeaderView(views::Widget* frame)
 198     : frame_(frame),
 199       header_painter_(new ash::DefaultHeaderPainter),
 200       avatar_icon_(NULL),
 201       caption_button_container_(NULL),
 202       fullscreen_visible_fraction_(0) {
 203   // Unfortunately, there is no views::WidgetDelegate::CanMinimize(). Assume
 204   // that the window frame can be minimized if it can be maximized.
 205   FrameCaptionButtonContainerView::MinimizeAllowed minimize_allowed =
 206       frame_->widget_delegate()->CanMaximize() ?
 207           FrameCaptionButtonContainerView::MINIMIZE_ALLOWED :
 208           FrameCaptionButtonContainerView::MINIMIZE_DISALLOWED;
 209   caption_button_container_ = new FrameCaptionButtonContainerView(frame_,
 210       minimize_allowed);
 211   caption_button_container_->UpdateSizeButtonVisibility();
 212   AddChildView(caption_button_container_);
 213
 214   header_painter_->Init(frame_, this, caption_button_container_);
 215   UpdateAvatarIcon();
 216
 217   Shell::GetInstance()->AddShellObserver(this);
 218 }
 219
 220 CustomFrameViewAsh::HeaderView::~HeaderView() {
 221   Shell::GetInstance()->RemoveShellObserver(this);
 222 }
 223
 224 void CustomFrameViewAsh::HeaderView::SchedulePaintForTitle() {
 225   header_painter_->SchedulePaintForTitle();
 226 }
 227
 228 void CustomFrameViewAsh::HeaderView::ResetWindowControls() {
 229   caption_button_container_->ResetWindowControls();
 230 }
 231
 232 int CustomFrameViewAsh::HeaderView::GetPreferredOnScreenHeight() const {
 233   if (frame_->IsFullscreen()) {
 234     return static_cast<int>(
 235         GetPreferredHeight() * fullscreen_visible_fraction_);
 236   }
 237   return GetPreferredHeight();
 238 }
 239
 240 int CustomFrameViewAsh::HeaderView::GetPreferredHeight() const {
 241   return header_painter_->GetHeaderHeightForPainting();
 242 }
 243
 244 int CustomFrameViewAsh::HeaderView::GetMinimumWidth() const {
 245   return header_painter_->GetMinimumHeaderWidth();
 246 }
 247
 248 void CustomFrameViewAsh::HeaderView::UpdateAvatarIcon() {
 249   SessionStateDelegate* delegate =
 250       Shell::GetInstance()->session_state_delegate();
 251   aura::Window* window = frame_->GetNativeView();
 252   bool show = delegate->ShouldShowAvatar(window);
 253   if (!show) {
 254     if (!avatar_icon_)
 255       return;
 256     delete avatar_icon_;
 257     avatar_icon_ = NULL;
 258   } else {
 259     gfx::ImageSkia image = GetAvatarImageForContext(
 260         delegate->GetBrowserContextForWindow(window)).AsImageSkia();
 261     DCHECK(!image.isNull());
 262     DCHECK_EQ(image.width(), image.height());
 263     if (!avatar_icon_) {
 264       avatar_icon_ = new views::ImageView();
 265       AddChildView(avatar_icon_);
 266     }
 267     avatar_icon_->SetImage(image);
 268   }
 269   header_painter_->UpdateLeftHeaderView(avatar_icon_);
 270   Layout();
 271 }
 272
 273 ///////////////////////////////////////////////////////////////////////////////
 274 // CustomFrameViewAsh::HeaderView, views::View overrides:
 275
 276 void CustomFrameViewAsh::HeaderView::Layout() {
 277   header_painter_->LayoutHeader();
 278 }
 279
 280 void CustomFrameViewAsh::HeaderView::OnPaint(gfx::Canvas* canvas) {
 281   bool paint_as_active =
 282       frame_->non_client_view()->frame_view()->ShouldPaintAsActive();
 283   caption_button_container_->SetPaintAsActive(paint_as_active);
 284
 285   HeaderPainter::Mode header_mode = paint_as_active ?
 286       HeaderPainter::MODE_ACTIVE : HeaderPainter::MODE_INACTIVE;
 287   header_painter_->PaintHeader(canvas, header_mode);
 288 }
 289
 290 void CustomFrameViewAsh::HeaderView::
 291     ChildPreferredSizeChanged(views::View* child) {
 292   // FrameCaptionButtonContainerView animates the visibility changes in
 293   // UpdateSizeButtonVisibility(false). Due to this a new size is not available
 294   // until the completion of the animation. Layout in response to the preferred
 295   // size changes.
 296   if (child != caption_button_container_)
 297     return;
 298   parent()->Layout();
 299 }
 300
 301 ///////////////////////////////////////////////////////////////////////////////
 302 // CustomFrameViewAsh::HeaderView, ShellObserver overrides:
 303
 304 void CustomFrameViewAsh::HeaderView::OnMaximizeModeStarted() {
 305   caption_button_container_->UpdateSizeButtonVisibility();
 306   parent()->Layout();
 307 }
 308
 309 void CustomFrameViewAsh::HeaderView::OnMaximizeModeEnded() {
 310   caption_button_container_->UpdateSizeButtonVisibility();
 311   parent()->Layout();
 312 }
 313
 314 ///////////////////////////////////////////////////////////////////////////////
 315 // CustomFrameViewAsh::HeaderView,
 316 //   ImmersiveFullscreenController::Delegate overrides:
 317
 318 void CustomFrameViewAsh::HeaderView::OnImmersiveRevealStarted() {
 319   fullscreen_visible_fraction_ = 0;
 320   SetPaintToLayer(true);
 321   SetFillsBoundsOpaquely(false);
 322   parent()->Layout();
 323 }
 324
 325 void CustomFrameViewAsh::HeaderView::OnImmersiveRevealEnded() {
 326   fullscreen_visible_fraction_ = 0;
 327   SetPaintToLayer(false);
 328   parent()->Layout();
 329 }
 330
 331 void CustomFrameViewAsh::HeaderView::OnImmersiveFullscreenExited() {
 332   fullscreen_visible_fraction_ = 0;
 333   SetPaintToLayer(false);
 334   parent()->Layout();
 335 }
 336
 337 void CustomFrameViewAsh::HeaderView::SetVisibleFraction(
 338     double visible_fraction) {
 339   if (fullscreen_visible_fraction_ != visible_fraction) {
 340     fullscreen_visible_fraction_ = visible_fraction;
 341     parent()->Layout();
 342   }
 343 }
 344
 345 std::vector<gfx::Rect>
 346 CustomFrameViewAsh::HeaderView::GetVisibleBoundsInScreen() const {
 347   // TODO(pkotwicz): Implement views::View::ConvertRectToScreen().
 348   gfx::Rect visible_bounds(GetVisibleBounds());
 349   gfx::Point visible_origin_in_screen(visible_bounds.origin());
 350   views::View::ConvertPointToScreen(this, &visible_origin_in_screen);
 351   std::vector<gfx::Rect> bounds_in_screen;
 352   bounds_in_screen.push_back(
 353       gfx::Rect(visible_origin_in_screen, visible_bounds.size()));
 354   return bounds_in_screen;
 355 }
 356
 357 ///////////////////////////////////////////////////////////////////////////////
 358 // CustomFrameViewAsh::OverlayView
 359
 360 // View which takes up the entire widget and contains the HeaderView. HeaderView
 361 // is a child of OverlayView to avoid creating a larger texture than necessary
 362 // when painting the HeaderView to its own layer.
 363 class CustomFrameViewAsh::OverlayView : public views::View,
 364                                         public views::ViewTargeterDelegate {
 365  public:
 366   explicit OverlayView(HeaderView* header_view);
 367   virtual ~OverlayView();
 368
 369   // views::View:
 370   virtual void Layout() OVERRIDE;
 371
 372  private:
 373   // views::ViewTargeterDelegate:
 374   virtual bool DoesIntersectRect(const views::View* target,
 375                                  const gfx::Rect& rect) const OVERRIDE;
 376
 377   HeaderView* header_view_;
 378
 379   DISALLOW_COPY_AND_ASSIGN(OverlayView);
 380 };
 381
 382 CustomFrameViewAsh::OverlayView::OverlayView(HeaderView* header_view)
 383     : header_view_(header_view) {
 384   AddChildView(header_view);
 385   SetEventTargeter(
 386       scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
 387 }
 388
 389 CustomFrameViewAsh::OverlayView::~OverlayView() {
 390 }
 391
 392 ///////////////////////////////////////////////////////////////////////////////
 393 // CustomFrameViewAsh::OverlayView, views::View overrides:
 394
 395 void CustomFrameViewAsh::OverlayView::Layout() {
 396   // Layout |header_view_| because layout affects the result of
 397   // GetPreferredOnScreenHeight().
 398   header_view_->Layout();
 399
 400   int onscreen_height = header_view_->GetPreferredOnScreenHeight();
 401   if (onscreen_height == 0) {
 402     header_view_->SetVisible(false);
 403   } else {
 404     int height = header_view_->GetPreferredHeight();
 405     header_view_->SetBounds(0, onscreen_height - height, width(), height);
 406     header_view_->SetVisible(true);
 407   }
 408 }
 409
 410 ///////////////////////////////////////////////////////////////////////////////
 411 // CustomFrameViewAsh::OverlayView, views::ViewTargeterDelegate overrides:
 412
 413 bool CustomFrameViewAsh::OverlayView::DoesIntersectRect(
 414     const views::View* target,
 415     const gfx::Rect& rect) const {
 416   CHECK_EQ(target, this);
 417   // Grab events in the header view. Return false for other events so that they
 418   // can be handled by the client view.
 419   return header_view_->HitTestRect(rect);
 420 }
 421
 422 ////////////////////////////////////////////////////////////////////////////////
 423 // CustomFrameViewAsh, public:
 424
 425 // static
 426 const char CustomFrameViewAsh::kViewClassName[] = "CustomFrameViewAsh";
 427
 428 CustomFrameViewAsh::CustomFrameViewAsh(views::Widget* frame)
 429     : frame_(frame),
 430       header_view_(new HeaderView(frame)),
 431       frame_border_hit_test_controller_(
 432           new FrameBorderHitTestController(frame_)) {
 433   // |header_view_| is set as the non client view's overlay view so that it can
 434   // overlay the web contents in immersive fullscreen.
 435   frame->non_client_view()->SetOverlayView(new OverlayView(header_view_));
 436
 437   // A delegate for a more complex way of fullscreening the window may already
 438   // be set. This is the case for packaged apps.
 439   wm::WindowState* window_state = wm::GetWindowState(frame->GetNativeWindow());
 440   if (!window_state->HasDelegate()) {
 441     window_state->SetDelegate(scoped_ptr<wm::WindowStateDelegate>(
 442         new CustomFrameViewAshWindowStateDelegate(
 443             window_state, this)));
 444   }
 445 }
 446
 447 CustomFrameViewAsh::~CustomFrameViewAsh() {
 448 }
 449
 450 void CustomFrameViewAsh::InitImmersiveFullscreenControllerForView(
 451     ImmersiveFullscreenController* immersive_fullscreen_controller) {
 452   immersive_fullscreen_controller->Init(header_view_, frame_, header_view_);
 453 }
 454
 455 ////////////////////////////////////////////////////////////////////////////////
 456 // CustomFrameViewAsh, views::NonClientFrameView overrides:
 457
 458 gfx::Rect CustomFrameViewAsh::GetBoundsForClientView() const {
 459   gfx::Rect client_bounds = bounds();
 460   client_bounds.Inset(0, NonClientTopBorderHeight(), 0, 0);
 461   return client_bounds;
 462 }
 463
 464 gfx::Rect CustomFrameViewAsh::GetWindowBoundsForClientBounds(
 465     const gfx::Rect& client_bounds) const {
 466   gfx::Rect window_bounds = client_bounds;
 467   window_bounds.Inset(0, -NonClientTopBorderHeight(), 0, 0);
 468   return window_bounds;
 469 }
 470
 471 int CustomFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
 472   return FrameBorderHitTestController::NonClientHitTest(this,
 473       header_view_->caption_button_container(), point);
 474 }
 475
 476 void CustomFrameViewAsh::GetWindowMask(const gfx::Size& size,
 477                                        gfx::Path* window_mask) {
 478   // No window masks in Aura.
 479 }
 480
 481 void CustomFrameViewAsh::ResetWindowControls() {
 482   header_view_->ResetWindowControls();
 483 }
 484
 485 void CustomFrameViewAsh::UpdateWindowIcon() {
 486 }
 487
 488 void CustomFrameViewAsh::UpdateWindowTitle() {
 489   header_view_->SchedulePaintForTitle();
 490 }
 491
 492 ////////////////////////////////////////////////////////////////////////////////
 493 // CustomFrameViewAsh, views::View overrides:
 494
 495 gfx::Size CustomFrameViewAsh::GetPreferredSize() const {
 496   gfx::Size pref = frame_->client_view()->GetPreferredSize();
 497   gfx::Rect bounds(0, 0, pref.width(), pref.height());
 498   return frame_->non_client_view()->GetWindowBoundsForClientBounds(
 499       bounds).size();
 500 }
 501
 502 const char* CustomFrameViewAsh::GetClassName() const {
 503   return kViewClassName;
 504 }
 505
 506 gfx::Size CustomFrameViewAsh::GetMinimumSize() const {
 507   gfx::Size min_client_view_size(frame_->client_view()->GetMinimumSize());
 508   return gfx::Size(
 509       std::max(header_view_->GetMinimumWidth(), min_client_view_size.width()),
 510       NonClientTopBorderHeight() + min_client_view_size.height());
 511 }
 512
 513 gfx::Size CustomFrameViewAsh::GetMaximumSize() const {
 514   gfx::Size max_client_size(frame_->client_view()->GetMaximumSize());
 515   int width = 0;
 516   int height = 0;
 517
 518   if (max_client_size.width() > 0)
 519     width = std::max(header_view_->GetMinimumWidth(), max_client_size.width());
 520   if (max_client_size.height() > 0)
 521     height = NonClientTopBorderHeight() + max_client_size.height();
 522
 523   return gfx::Size(width, height);
 524 }
 525
 526 void CustomFrameViewAsh::SchedulePaintInRect(const gfx::Rect& r) {
 527   // We may end up here before |header_view_| has been added to the Widget.
 528   if (header_view_->GetWidget()) {
 529     // The HeaderView is not a child of CustomFrameViewAsh. Redirect the paint
 530     // to HeaderView instead.
 531     gfx::RectF to_paint(r);
 532     views::View::ConvertRectToTarget(this, header_view_, &to_paint);
 533     header_view_->SchedulePaintInRect(gfx::ToEnclosingRect(to_paint));
 534   } else {
 535     views::NonClientFrameView::SchedulePaintInRect(r);
 536   }
 537 }
 538
 539 void CustomFrameViewAsh::VisibilityChanged(views::View* starting_from,
 540                                            bool is_visible) {
 541   if (is_visible)
 542     header_view_->UpdateAvatarIcon();
 543 }
 544
 545 ////////////////////////////////////////////////////////////////////////////////
 546 // CustomFrameViewAsh, views::ViewTargeterDelegate overrides:
 547
 548 views::View* CustomFrameViewAsh::GetHeaderView() {
 549   return header_view_;
 550 }
 551
 552 const views::View* CustomFrameViewAsh::GetAvatarIconViewForTest() const {
 553   return header_view_->avatar_icon();
 554 }
 555
 556 ////////////////////////////////////////////////////////////////////////////////
 557 // CustomFrameViewAsh, private:
 558
 559 // views::NonClientFrameView:
 560 bool CustomFrameViewAsh::DoesIntersectRect(const views::View* target,
 561                                            const gfx::Rect& rect) const {
 562   CHECK_EQ(target, this);
 563   // NonClientView hit tests the NonClientFrameView first instead of going in
 564   // z-order. Return false so that events get to the OverlayView.
 565   return false;
 566 }
 567
 568 FrameCaptionButtonContainerView* CustomFrameViewAsh::
 569     GetFrameCaptionButtonContainerViewForTest() {
 570   return header_view_->caption_button_container();
 571 }
 572
 573 int CustomFrameViewAsh::NonClientTopBorderHeight() const {
 574   return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
 575 }
 576
 577 }  // namespace ash