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
38namespace {
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.
46class 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
121namespace ash {
122
123///////////////////////////////////////////////////////////////////////////////
124// CustomFrameViewAsh::HeaderView
125
126// View which paints the header. It slides off and on screen in immersive
127// fullscreen.
128class 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  void SizeConstraintsChanged();
155
156  // views::View:
157  virtual void Layout() OVERRIDE;
158  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
159  virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE;
160
161  // ShellObserver:
162  virtual void OnMaximizeModeStarted() OVERRIDE;
163  virtual void OnMaximizeModeEnded() OVERRIDE;
164
165  FrameCaptionButtonContainerView* caption_button_container() {
166    return caption_button_container_;
167  }
168
169  views::View* avatar_icon() const {
170    return avatar_icon_;
171  }
172
173 private:
174  // ImmersiveFullscreenController::Delegate:
175  virtual void OnImmersiveRevealStarted() OVERRIDE;
176  virtual void OnImmersiveRevealEnded() OVERRIDE;
177  virtual void OnImmersiveFullscreenExited() OVERRIDE;
178  virtual void SetVisibleFraction(double visible_fraction) OVERRIDE;
179  virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() const OVERRIDE;
180
181  // The widget that the caption buttons act on.
182  views::Widget* frame_;
183
184  // Helper for painting the header.
185  scoped_ptr<DefaultHeaderPainter> header_painter_;
186
187  views::ImageView* avatar_icon_;
188
189  // View which contains the window caption buttons.
190  FrameCaptionButtonContainerView* caption_button_container_;
191
192  // The fraction of the header's height which is visible while in fullscreen.
193  // This value is meaningless when not in fullscreen.
194  double fullscreen_visible_fraction_;
195
196  DISALLOW_COPY_AND_ASSIGN(HeaderView);
197};
198
199CustomFrameViewAsh::HeaderView::HeaderView(views::Widget* frame)
200    : frame_(frame),
201      header_painter_(new ash::DefaultHeaderPainter),
202      avatar_icon_(NULL),
203      caption_button_container_(NULL),
204      fullscreen_visible_fraction_(0) {
205  FrameCaptionButtonContainerView::MinimizeAllowed minimize_allowed =
206      frame_->widget_delegate()->CanMinimize() ?
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
220CustomFrameViewAsh::HeaderView::~HeaderView() {
221  Shell::GetInstance()->RemoveShellObserver(this);
222}
223
224void CustomFrameViewAsh::HeaderView::SchedulePaintForTitle() {
225  header_painter_->SchedulePaintForTitle();
226}
227
228void CustomFrameViewAsh::HeaderView::ResetWindowControls() {
229  caption_button_container_->ResetWindowControls();
230}
231
232int CustomFrameViewAsh::HeaderView::GetPreferredOnScreenHeight() const {
233  if (frame_->IsFullscreen()) {
234    return static_cast<int>(
235        GetPreferredHeight() * fullscreen_visible_fraction_);
236  }
237  return GetPreferredHeight();
238}
239
240int CustomFrameViewAsh::HeaderView::GetPreferredHeight() const {
241  return header_painter_->GetHeaderHeightForPainting();
242}
243
244int CustomFrameViewAsh::HeaderView::GetMinimumWidth() const {
245  return header_painter_->GetMinimumHeaderWidth();
246}
247
248void 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
273void CustomFrameViewAsh::HeaderView::SizeConstraintsChanged() {
274  caption_button_container_->ResetWindowControls();
275  caption_button_container_->UpdateSizeButtonVisibility();
276  Layout();
277}
278
279///////////////////////////////////////////////////////////////////////////////
280// CustomFrameViewAsh::HeaderView, views::View overrides:
281
282void CustomFrameViewAsh::HeaderView::Layout() {
283  header_painter_->LayoutHeader();
284}
285
286void CustomFrameViewAsh::HeaderView::OnPaint(gfx::Canvas* canvas) {
287  bool paint_as_active =
288      frame_->non_client_view()->frame_view()->ShouldPaintAsActive();
289  caption_button_container_->SetPaintAsActive(paint_as_active);
290
291  HeaderPainter::Mode header_mode = paint_as_active ?
292      HeaderPainter::MODE_ACTIVE : HeaderPainter::MODE_INACTIVE;
293  header_painter_->PaintHeader(canvas, header_mode);
294}
295
296void CustomFrameViewAsh::HeaderView::
297    ChildPreferredSizeChanged(views::View* child) {
298  // FrameCaptionButtonContainerView animates the visibility changes in
299  // UpdateSizeButtonVisibility(false). Due to this a new size is not available
300  // until the completion of the animation. Layout in response to the preferred
301  // size changes.
302  if (child != caption_button_container_)
303    return;
304  parent()->Layout();
305}
306
307///////////////////////////////////////////////////////////////////////////////
308// CustomFrameViewAsh::HeaderView, ShellObserver overrides:
309
310void CustomFrameViewAsh::HeaderView::OnMaximizeModeStarted() {
311  caption_button_container_->UpdateSizeButtonVisibility();
312  parent()->Layout();
313}
314
315void CustomFrameViewAsh::HeaderView::OnMaximizeModeEnded() {
316  caption_button_container_->UpdateSizeButtonVisibility();
317  parent()->Layout();
318}
319
320///////////////////////////////////////////////////////////////////////////////
321// CustomFrameViewAsh::HeaderView,
322//   ImmersiveFullscreenController::Delegate overrides:
323
324void CustomFrameViewAsh::HeaderView::OnImmersiveRevealStarted() {
325  fullscreen_visible_fraction_ = 0;
326  SetPaintToLayer(true);
327  SetFillsBoundsOpaquely(false);
328  parent()->Layout();
329}
330
331void CustomFrameViewAsh::HeaderView::OnImmersiveRevealEnded() {
332  fullscreen_visible_fraction_ = 0;
333  SetPaintToLayer(false);
334  parent()->Layout();
335}
336
337void CustomFrameViewAsh::HeaderView::OnImmersiveFullscreenExited() {
338  fullscreen_visible_fraction_ = 0;
339  SetPaintToLayer(false);
340  parent()->Layout();
341}
342
343void CustomFrameViewAsh::HeaderView::SetVisibleFraction(
344    double visible_fraction) {
345  if (fullscreen_visible_fraction_ != visible_fraction) {
346    fullscreen_visible_fraction_ = visible_fraction;
347    parent()->Layout();
348  }
349}
350
351std::vector<gfx::Rect>
352CustomFrameViewAsh::HeaderView::GetVisibleBoundsInScreen() const {
353  // TODO(pkotwicz): Implement views::View::ConvertRectToScreen().
354  gfx::Rect visible_bounds(GetVisibleBounds());
355  gfx::Point visible_origin_in_screen(visible_bounds.origin());
356  views::View::ConvertPointToScreen(this, &visible_origin_in_screen);
357  std::vector<gfx::Rect> bounds_in_screen;
358  bounds_in_screen.push_back(
359      gfx::Rect(visible_origin_in_screen, visible_bounds.size()));
360  return bounds_in_screen;
361}
362
363///////////////////////////////////////////////////////////////////////////////
364// CustomFrameViewAsh::OverlayView
365
366// View which takes up the entire widget and contains the HeaderView. HeaderView
367// is a child of OverlayView to avoid creating a larger texture than necessary
368// when painting the HeaderView to its own layer.
369class CustomFrameViewAsh::OverlayView : public views::View,
370                                        public views::ViewTargeterDelegate {
371 public:
372  explicit OverlayView(HeaderView* header_view);
373  virtual ~OverlayView();
374
375  // views::View:
376  virtual void Layout() OVERRIDE;
377
378 private:
379  // views::ViewTargeterDelegate:
380  virtual bool DoesIntersectRect(const views::View* target,
381                                 const gfx::Rect& rect) const OVERRIDE;
382
383  HeaderView* header_view_;
384
385  DISALLOW_COPY_AND_ASSIGN(OverlayView);
386};
387
388CustomFrameViewAsh::OverlayView::OverlayView(HeaderView* header_view)
389    : header_view_(header_view) {
390  AddChildView(header_view);
391  SetEventTargeter(
392      scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
393}
394
395CustomFrameViewAsh::OverlayView::~OverlayView() {
396}
397
398///////////////////////////////////////////////////////////////////////////////
399// CustomFrameViewAsh::OverlayView, views::View overrides:
400
401void CustomFrameViewAsh::OverlayView::Layout() {
402  // Layout |header_view_| because layout affects the result of
403  // GetPreferredOnScreenHeight().
404  header_view_->Layout();
405
406  int onscreen_height = header_view_->GetPreferredOnScreenHeight();
407  if (onscreen_height == 0) {
408    header_view_->SetVisible(false);
409  } else {
410    int height = header_view_->GetPreferredHeight();
411    header_view_->SetBounds(0, onscreen_height - height, width(), height);
412    header_view_->SetVisible(true);
413  }
414}
415
416///////////////////////////////////////////////////////////////////////////////
417// CustomFrameViewAsh::OverlayView, views::ViewTargeterDelegate overrides:
418
419bool CustomFrameViewAsh::OverlayView::DoesIntersectRect(
420    const views::View* target,
421    const gfx::Rect& rect) const {
422  CHECK_EQ(target, this);
423  // Grab events in the header view. Return false for other events so that they
424  // can be handled by the client view.
425  return header_view_->HitTestRect(rect);
426}
427
428////////////////////////////////////////////////////////////////////////////////
429// CustomFrameViewAsh, public:
430
431// static
432const char CustomFrameViewAsh::kViewClassName[] = "CustomFrameViewAsh";
433
434CustomFrameViewAsh::CustomFrameViewAsh(views::Widget* frame)
435    : frame_(frame),
436      header_view_(new HeaderView(frame)),
437      frame_border_hit_test_controller_(
438          new FrameBorderHitTestController(frame_)) {
439  // |header_view_| is set as the non client view's overlay view so that it can
440  // overlay the web contents in immersive fullscreen.
441  frame->non_client_view()->SetOverlayView(new OverlayView(header_view_));
442
443  // A delegate for a more complex way of fullscreening the window may already
444  // be set. This is the case for packaged apps.
445  wm::WindowState* window_state = wm::GetWindowState(frame->GetNativeWindow());
446  if (!window_state->HasDelegate()) {
447    window_state->SetDelegate(scoped_ptr<wm::WindowStateDelegate>(
448        new CustomFrameViewAshWindowStateDelegate(
449            window_state, this)));
450  }
451}
452
453CustomFrameViewAsh::~CustomFrameViewAsh() {
454}
455
456void CustomFrameViewAsh::InitImmersiveFullscreenControllerForView(
457    ImmersiveFullscreenController* immersive_fullscreen_controller) {
458  immersive_fullscreen_controller->Init(header_view_, frame_, header_view_);
459}
460
461////////////////////////////////////////////////////////////////////////////////
462// CustomFrameViewAsh, views::NonClientFrameView overrides:
463
464gfx::Rect CustomFrameViewAsh::GetBoundsForClientView() const {
465  gfx::Rect client_bounds = bounds();
466  client_bounds.Inset(0, NonClientTopBorderHeight(), 0, 0);
467  return client_bounds;
468}
469
470gfx::Rect CustomFrameViewAsh::GetWindowBoundsForClientBounds(
471    const gfx::Rect& client_bounds) const {
472  gfx::Rect window_bounds = client_bounds;
473  window_bounds.Inset(0, -NonClientTopBorderHeight(), 0, 0);
474  return window_bounds;
475}
476
477int CustomFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
478  return FrameBorderHitTestController::NonClientHitTest(this,
479      header_view_->caption_button_container(), point);
480}
481
482void CustomFrameViewAsh::GetWindowMask(const gfx::Size& size,
483                                       gfx::Path* window_mask) {
484  // No window masks in Aura.
485}
486
487void CustomFrameViewAsh::ResetWindowControls() {
488  header_view_->ResetWindowControls();
489}
490
491void CustomFrameViewAsh::UpdateWindowIcon() {
492}
493
494void CustomFrameViewAsh::UpdateWindowTitle() {
495  header_view_->SchedulePaintForTitle();
496}
497
498void CustomFrameViewAsh::SizeConstraintsChanged() {
499  header_view_->SizeConstraintsChanged();
500}
501
502////////////////////////////////////////////////////////////////////////////////
503// CustomFrameViewAsh, views::View overrides:
504
505gfx::Size CustomFrameViewAsh::GetPreferredSize() const {
506  gfx::Size pref = frame_->client_view()->GetPreferredSize();
507  gfx::Rect bounds(0, 0, pref.width(), pref.height());
508  return frame_->non_client_view()->GetWindowBoundsForClientBounds(
509      bounds).size();
510}
511
512const char* CustomFrameViewAsh::GetClassName() const {
513  return kViewClassName;
514}
515
516gfx::Size CustomFrameViewAsh::GetMinimumSize() const {
517  gfx::Size min_client_view_size(frame_->client_view()->GetMinimumSize());
518  return gfx::Size(
519      std::max(header_view_->GetMinimumWidth(), min_client_view_size.width()),
520      NonClientTopBorderHeight() + min_client_view_size.height());
521}
522
523gfx::Size CustomFrameViewAsh::GetMaximumSize() const {
524  gfx::Size max_client_size(frame_->client_view()->GetMaximumSize());
525  int width = 0;
526  int height = 0;
527
528  if (max_client_size.width() > 0)
529    width = std::max(header_view_->GetMinimumWidth(), max_client_size.width());
530  if (max_client_size.height() > 0)
531    height = NonClientTopBorderHeight() + max_client_size.height();
532
533  return gfx::Size(width, height);
534}
535
536void CustomFrameViewAsh::SchedulePaintInRect(const gfx::Rect& r) {
537  // We may end up here before |header_view_| has been added to the Widget.
538  if (header_view_->GetWidget()) {
539    // The HeaderView is not a child of CustomFrameViewAsh. Redirect the paint
540    // to HeaderView instead.
541    gfx::RectF to_paint(r);
542    views::View::ConvertRectToTarget(this, header_view_, &to_paint);
543    header_view_->SchedulePaintInRect(gfx::ToEnclosingRect(to_paint));
544  } else {
545    views::NonClientFrameView::SchedulePaintInRect(r);
546  }
547}
548
549void CustomFrameViewAsh::VisibilityChanged(views::View* starting_from,
550                                           bool is_visible) {
551  if (is_visible)
552    header_view_->UpdateAvatarIcon();
553}
554
555////////////////////////////////////////////////////////////////////////////////
556// CustomFrameViewAsh, views::ViewTargeterDelegate overrides:
557
558views::View* CustomFrameViewAsh::GetHeaderView() {
559  return header_view_;
560}
561
562const views::View* CustomFrameViewAsh::GetAvatarIconViewForTest() const {
563  return header_view_->avatar_icon();
564}
565
566////////////////////////////////////////////////////////////////////////////////
567// CustomFrameViewAsh, private:
568
569// views::NonClientFrameView:
570bool CustomFrameViewAsh::DoesIntersectRect(const views::View* target,
571                                           const gfx::Rect& rect) const {
572  CHECK_EQ(target, this);
573  // NonClientView hit tests the NonClientFrameView first instead of going in
574  // z-order. Return false so that events get to the OverlayView.
575  return false;
576}
577
578FrameCaptionButtonContainerView* CustomFrameViewAsh::
579    GetFrameCaptionButtonContainerViewForTest() {
580  return header_view_->caption_button_container();
581}
582
583int CustomFrameViewAsh::NonClientTopBorderHeight() const {
584  return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
585}
586
587}  // namespace ash
588