blob: f4422fc796e412210b6de7c1f931a5c06d13b326 [file] [log] [blame]
// Copyright (c) 2012 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 "ash/frame/custom_frame_view_ash.h"
#include <algorithm>
#include <vector>
#include "ash/ash_switches.h"
#include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
#include "ash/frame/default_header_painter.h"
#include "ash/frame/frame_border_hit_test_controller.h"
#include "ash/frame/frame_util.h"
#include "ash/frame/header_painter.h"
#include "ash/session/session_state_delegate.h"
#include "ash/shell.h"
#include "ash/shell_observer.h"
#include "ash/wm/immersive_fullscreen_controller.h"
#include "ash/wm/window_state.h"
#include "ash/wm/window_state_delegate.h"
#include "ash/wm/window_state_observer.h"
#include "base/command_line.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/window.h"
#include "ui/aura/window_observer.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/image/image.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/rect_conversions.h"
#include "ui/gfx/size.h"
#include "ui/views/controls/image_view.h"
#include "ui/views/view.h"
#include "ui/views/view_targeter.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_delegate.h"
namespace {
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAshWindowStateDelegate
// Handles a user's fullscreen request (Shift+F4/F4). Puts the window into
// immersive fullscreen if immersive fullscreen is enabled for non-browser
// windows.
class CustomFrameViewAshWindowStateDelegate
: public ash::wm::WindowStateDelegate,
public ash::wm::WindowStateObserver,
public aura::WindowObserver {
public:
CustomFrameViewAshWindowStateDelegate(
ash::wm::WindowState* window_state,
ash::CustomFrameViewAsh* custom_frame_view)
: window_state_(NULL) {
immersive_fullscreen_controller_.reset(
new ash::ImmersiveFullscreenController);
custom_frame_view->InitImmersiveFullscreenControllerForView(
immersive_fullscreen_controller_.get());
// Add a window state observer to exit fullscreen properly in case
// fullscreen is exited without going through
// WindowState::ToggleFullscreen(). This is the case when exiting
// immersive fullscreen via the "Restore" window control.
// TODO(pkotwicz): This is a hack. Remove ASAP. http://crbug.com/319048
window_state_ = window_state;
window_state_->AddObserver(this);
window_state_->window()->AddObserver(this);
}
virtual ~CustomFrameViewAshWindowStateDelegate() {
if (window_state_) {
window_state_->RemoveObserver(this);
window_state_->window()->RemoveObserver(this);
}
}
private:
// Overridden from ash::wm::WindowStateDelegate:
virtual bool ToggleFullscreen(ash::wm::WindowState* window_state) OVERRIDE {
bool enter_fullscreen = !window_state->IsFullscreen();
if (enter_fullscreen) {
window_state->window()->SetProperty(aura::client::kShowStateKey,
ui::SHOW_STATE_FULLSCREEN);
} else {
window_state->Restore();
}
if (immersive_fullscreen_controller_) {
immersive_fullscreen_controller_->SetEnabled(
ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
enter_fullscreen);
}
return true;
}
// Overridden from aura::WindowObserver:
virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
window_state_->RemoveObserver(this);
window_state_->window()->RemoveObserver(this);
window_state_ = NULL;
}
// Overridden from ash::wm::WindowStateObserver:
virtual void OnPostWindowStateTypeChange(
ash::wm::WindowState* window_state,
ash::wm::WindowStateType old_type) OVERRIDE {
if (!window_state->IsFullscreen() &&
!window_state->IsMinimized() &&
immersive_fullscreen_controller_.get() &&
immersive_fullscreen_controller_->IsEnabled()) {
immersive_fullscreen_controller_->SetEnabled(
ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
false);
}
}
ash::wm::WindowState* window_state_;
scoped_ptr<ash::ImmersiveFullscreenController>
immersive_fullscreen_controller_;
DISALLOW_COPY_AND_ASSIGN(CustomFrameViewAshWindowStateDelegate);
};
} // namespace
namespace ash {
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh::HeaderView
// View which paints the header. It slides off and on screen in immersive
// fullscreen.
class CustomFrameViewAsh::HeaderView
: public views::View,
public ImmersiveFullscreenController::Delegate,
public ShellObserver {
public:
// |frame| is the widget that the caption buttons act on.
explicit HeaderView(views::Widget* frame);
virtual ~HeaderView();
// Schedules a repaint for the entire title.
void SchedulePaintForTitle();
// Tells the window controls to reset themselves to the normal state.
void ResetWindowControls();
// Returns the amount of the view's pixels which should be on screen.
int GetPreferredOnScreenHeight() const;
// Returns the view's preferred height.
int GetPreferredHeight() const;
// Returns the view's minimum width.
int GetMinimumWidth() const;
void UpdateAvatarIcon();
void SizeConstraintsChanged();
// views::View:
virtual void Layout() OVERRIDE;
virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE;
// ShellObserver:
virtual void OnMaximizeModeStarted() OVERRIDE;
virtual void OnMaximizeModeEnded() OVERRIDE;
FrameCaptionButtonContainerView* caption_button_container() {
return caption_button_container_;
}
views::View* avatar_icon() const {
return avatar_icon_;
}
private:
// ImmersiveFullscreenController::Delegate:
virtual void OnImmersiveRevealStarted() OVERRIDE;
virtual void OnImmersiveRevealEnded() OVERRIDE;
virtual void OnImmersiveFullscreenExited() OVERRIDE;
virtual void SetVisibleFraction(double visible_fraction) OVERRIDE;
virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() const OVERRIDE;
// The widget that the caption buttons act on.
views::Widget* frame_;
// Helper for painting the header.
scoped_ptr<DefaultHeaderPainter> header_painter_;
views::ImageView* avatar_icon_;
// View which contains the window caption buttons.
FrameCaptionButtonContainerView* caption_button_container_;
// The fraction of the header's height which is visible while in fullscreen.
// This value is meaningless when not in fullscreen.
double fullscreen_visible_fraction_;
DISALLOW_COPY_AND_ASSIGN(HeaderView);
};
CustomFrameViewAsh::HeaderView::HeaderView(views::Widget* frame)
: frame_(frame),
header_painter_(new ash::DefaultHeaderPainter),
avatar_icon_(NULL),
caption_button_container_(NULL),
fullscreen_visible_fraction_(0) {
FrameCaptionButtonContainerView::MinimizeAllowed minimize_allowed =
frame_->widget_delegate()->CanMinimize() ?
FrameCaptionButtonContainerView::MINIMIZE_ALLOWED :
FrameCaptionButtonContainerView::MINIMIZE_DISALLOWED;
caption_button_container_ = new FrameCaptionButtonContainerView(frame_,
minimize_allowed);
caption_button_container_->UpdateSizeButtonVisibility();
AddChildView(caption_button_container_);
header_painter_->Init(frame_, this, caption_button_container_);
UpdateAvatarIcon();
Shell::GetInstance()->AddShellObserver(this);
}
CustomFrameViewAsh::HeaderView::~HeaderView() {
Shell::GetInstance()->RemoveShellObserver(this);
}
void CustomFrameViewAsh::HeaderView::SchedulePaintForTitle() {
header_painter_->SchedulePaintForTitle();
}
void CustomFrameViewAsh::HeaderView::ResetWindowControls() {
caption_button_container_->ResetWindowControls();
}
int CustomFrameViewAsh::HeaderView::GetPreferredOnScreenHeight() const {
if (frame_->IsFullscreen()) {
return static_cast<int>(
GetPreferredHeight() * fullscreen_visible_fraction_);
}
return GetPreferredHeight();
}
int CustomFrameViewAsh::HeaderView::GetPreferredHeight() const {
return header_painter_->GetHeaderHeightForPainting();
}
int CustomFrameViewAsh::HeaderView::GetMinimumWidth() const {
return header_painter_->GetMinimumHeaderWidth();
}
void CustomFrameViewAsh::HeaderView::UpdateAvatarIcon() {
SessionStateDelegate* delegate =
Shell::GetInstance()->session_state_delegate();
aura::Window* window = frame_->GetNativeView();
bool show = delegate->ShouldShowAvatar(window);
if (!show) {
if (!avatar_icon_)
return;
delete avatar_icon_;
avatar_icon_ = NULL;
} else {
gfx::ImageSkia image = GetAvatarImageForContext(
delegate->GetBrowserContextForWindow(window)).AsImageSkia();
DCHECK(!image.isNull());
DCHECK_EQ(image.width(), image.height());
if (!avatar_icon_) {
avatar_icon_ = new views::ImageView();
AddChildView(avatar_icon_);
}
avatar_icon_->SetImage(image);
}
header_painter_->UpdateLeftHeaderView(avatar_icon_);
Layout();
}
void CustomFrameViewAsh::HeaderView::SizeConstraintsChanged() {
caption_button_container_->ResetWindowControls();
caption_button_container_->UpdateSizeButtonVisibility();
Layout();
}
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh::HeaderView, views::View overrides:
void CustomFrameViewAsh::HeaderView::Layout() {
header_painter_->LayoutHeader();
}
void CustomFrameViewAsh::HeaderView::OnPaint(gfx::Canvas* canvas) {
bool paint_as_active =
frame_->non_client_view()->frame_view()->ShouldPaintAsActive();
caption_button_container_->SetPaintAsActive(paint_as_active);
HeaderPainter::Mode header_mode = paint_as_active ?
HeaderPainter::MODE_ACTIVE : HeaderPainter::MODE_INACTIVE;
header_painter_->PaintHeader(canvas, header_mode);
}
void CustomFrameViewAsh::HeaderView::
ChildPreferredSizeChanged(views::View* child) {
// FrameCaptionButtonContainerView animates the visibility changes in
// UpdateSizeButtonVisibility(false). Due to this a new size is not available
// until the completion of the animation. Layout in response to the preferred
// size changes.
if (child != caption_button_container_)
return;
parent()->Layout();
}
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh::HeaderView, ShellObserver overrides:
void CustomFrameViewAsh::HeaderView::OnMaximizeModeStarted() {
caption_button_container_->UpdateSizeButtonVisibility();
parent()->Layout();
}
void CustomFrameViewAsh::HeaderView::OnMaximizeModeEnded() {
caption_button_container_->UpdateSizeButtonVisibility();
parent()->Layout();
}
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh::HeaderView,
// ImmersiveFullscreenController::Delegate overrides:
void CustomFrameViewAsh::HeaderView::OnImmersiveRevealStarted() {
fullscreen_visible_fraction_ = 0;
SetPaintToLayer(true);
SetFillsBoundsOpaquely(false);
parent()->Layout();
}
void CustomFrameViewAsh::HeaderView::OnImmersiveRevealEnded() {
fullscreen_visible_fraction_ = 0;
SetPaintToLayer(false);
parent()->Layout();
}
void CustomFrameViewAsh::HeaderView::OnImmersiveFullscreenExited() {
fullscreen_visible_fraction_ = 0;
SetPaintToLayer(false);
parent()->Layout();
}
void CustomFrameViewAsh::HeaderView::SetVisibleFraction(
double visible_fraction) {
if (fullscreen_visible_fraction_ != visible_fraction) {
fullscreen_visible_fraction_ = visible_fraction;
parent()->Layout();
}
}
std::vector<gfx::Rect>
CustomFrameViewAsh::HeaderView::GetVisibleBoundsInScreen() const {
// TODO(pkotwicz): Implement views::View::ConvertRectToScreen().
gfx::Rect visible_bounds(GetVisibleBounds());
gfx::Point visible_origin_in_screen(visible_bounds.origin());
views::View::ConvertPointToScreen(this, &visible_origin_in_screen);
std::vector<gfx::Rect> bounds_in_screen;
bounds_in_screen.push_back(
gfx::Rect(visible_origin_in_screen, visible_bounds.size()));
return bounds_in_screen;
}
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh::OverlayView
// View which takes up the entire widget and contains the HeaderView. HeaderView
// is a child of OverlayView to avoid creating a larger texture than necessary
// when painting the HeaderView to its own layer.
class CustomFrameViewAsh::OverlayView : public views::View,
public views::ViewTargeterDelegate {
public:
explicit OverlayView(HeaderView* header_view);
virtual ~OverlayView();
// views::View:
virtual void Layout() OVERRIDE;
private:
// views::ViewTargeterDelegate:
virtual bool DoesIntersectRect(const views::View* target,
const gfx::Rect& rect) const OVERRIDE;
HeaderView* header_view_;
DISALLOW_COPY_AND_ASSIGN(OverlayView);
};
CustomFrameViewAsh::OverlayView::OverlayView(HeaderView* header_view)
: header_view_(header_view) {
AddChildView(header_view);
SetEventTargeter(
scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
}
CustomFrameViewAsh::OverlayView::~OverlayView() {
}
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh::OverlayView, views::View overrides:
void CustomFrameViewAsh::OverlayView::Layout() {
// Layout |header_view_| because layout affects the result of
// GetPreferredOnScreenHeight().
header_view_->Layout();
int onscreen_height = header_view_->GetPreferredOnScreenHeight();
if (onscreen_height == 0) {
header_view_->SetVisible(false);
} else {
int height = header_view_->GetPreferredHeight();
header_view_->SetBounds(0, onscreen_height - height, width(), height);
header_view_->SetVisible(true);
}
}
///////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh::OverlayView, views::ViewTargeterDelegate overrides:
bool CustomFrameViewAsh::OverlayView::DoesIntersectRect(
const views::View* target,
const gfx::Rect& rect) const {
CHECK_EQ(target, this);
// Grab events in the header view. Return false for other events so that they
// can be handled by the client view.
return header_view_->HitTestRect(rect);
}
////////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh, public:
// static
const char CustomFrameViewAsh::kViewClassName[] = "CustomFrameViewAsh";
CustomFrameViewAsh::CustomFrameViewAsh(views::Widget* frame)
: frame_(frame),
header_view_(new HeaderView(frame)),
frame_border_hit_test_controller_(
new FrameBorderHitTestController(frame_)) {
// |header_view_| is set as the non client view's overlay view so that it can
// overlay the web contents in immersive fullscreen.
frame->non_client_view()->SetOverlayView(new OverlayView(header_view_));
// A delegate for a more complex way of fullscreening the window may already
// be set. This is the case for packaged apps.
wm::WindowState* window_state = wm::GetWindowState(frame->GetNativeWindow());
if (!window_state->HasDelegate()) {
window_state->SetDelegate(scoped_ptr<wm::WindowStateDelegate>(
new CustomFrameViewAshWindowStateDelegate(
window_state, this)));
}
}
CustomFrameViewAsh::~CustomFrameViewAsh() {
}
void CustomFrameViewAsh::InitImmersiveFullscreenControllerForView(
ImmersiveFullscreenController* immersive_fullscreen_controller) {
immersive_fullscreen_controller->Init(header_view_, frame_, header_view_);
}
////////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh, views::NonClientFrameView overrides:
gfx::Rect CustomFrameViewAsh::GetBoundsForClientView() const {
gfx::Rect client_bounds = bounds();
client_bounds.Inset(0, NonClientTopBorderHeight(), 0, 0);
return client_bounds;
}
gfx::Rect CustomFrameViewAsh::GetWindowBoundsForClientBounds(
const gfx::Rect& client_bounds) const {
gfx::Rect window_bounds = client_bounds;
window_bounds.Inset(0, -NonClientTopBorderHeight(), 0, 0);
return window_bounds;
}
int CustomFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
return FrameBorderHitTestController::NonClientHitTest(this,
header_view_->caption_button_container(), point);
}
void CustomFrameViewAsh::GetWindowMask(const gfx::Size& size,
gfx::Path* window_mask) {
// No window masks in Aura.
}
void CustomFrameViewAsh::ResetWindowControls() {
header_view_->ResetWindowControls();
}
void CustomFrameViewAsh::UpdateWindowIcon() {
}
void CustomFrameViewAsh::UpdateWindowTitle() {
header_view_->SchedulePaintForTitle();
}
void CustomFrameViewAsh::SizeConstraintsChanged() {
header_view_->SizeConstraintsChanged();
}
////////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh, views::View overrides:
gfx::Size CustomFrameViewAsh::GetPreferredSize() const {
gfx::Size pref = frame_->client_view()->GetPreferredSize();
gfx::Rect bounds(0, 0, pref.width(), pref.height());
return frame_->non_client_view()->GetWindowBoundsForClientBounds(
bounds).size();
}
const char* CustomFrameViewAsh::GetClassName() const {
return kViewClassName;
}
gfx::Size CustomFrameViewAsh::GetMinimumSize() const {
gfx::Size min_client_view_size(frame_->client_view()->GetMinimumSize());
return gfx::Size(
std::max(header_view_->GetMinimumWidth(), min_client_view_size.width()),
NonClientTopBorderHeight() + min_client_view_size.height());
}
gfx::Size CustomFrameViewAsh::GetMaximumSize() const {
gfx::Size max_client_size(frame_->client_view()->GetMaximumSize());
int width = 0;
int height = 0;
if (max_client_size.width() > 0)
width = std::max(header_view_->GetMinimumWidth(), max_client_size.width());
if (max_client_size.height() > 0)
height = NonClientTopBorderHeight() + max_client_size.height();
return gfx::Size(width, height);
}
void CustomFrameViewAsh::SchedulePaintInRect(const gfx::Rect& r) {
// We may end up here before |header_view_| has been added to the Widget.
if (header_view_->GetWidget()) {
// The HeaderView is not a child of CustomFrameViewAsh. Redirect the paint
// to HeaderView instead.
gfx::RectF to_paint(r);
views::View::ConvertRectToTarget(this, header_view_, &to_paint);
header_view_->SchedulePaintInRect(gfx::ToEnclosingRect(to_paint));
} else {
views::NonClientFrameView::SchedulePaintInRect(r);
}
}
void CustomFrameViewAsh::VisibilityChanged(views::View* starting_from,
bool is_visible) {
if (is_visible)
header_view_->UpdateAvatarIcon();
}
////////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh, views::ViewTargeterDelegate overrides:
views::View* CustomFrameViewAsh::GetHeaderView() {
return header_view_;
}
const views::View* CustomFrameViewAsh::GetAvatarIconViewForTest() const {
return header_view_->avatar_icon();
}
////////////////////////////////////////////////////////////////////////////////
// CustomFrameViewAsh, private:
// views::NonClientFrameView:
bool CustomFrameViewAsh::DoesIntersectRect(const views::View* target,
const gfx::Rect& rect) const {
CHECK_EQ(target, this);
// NonClientView hit tests the NonClientFrameView first instead of going in
// z-order. Return false so that events get to the OverlayView.
return false;
}
FrameCaptionButtonContainerView* CustomFrameViewAsh::
GetFrameCaptionButtonContainerViewForTest() {
return header_view_->caption_button_container();
}
int CustomFrameViewAsh::NonClientTopBorderHeight() const {
return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
}
} // namespace ash