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