// Copyright 2013 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/wm/header_painter.h"
#include <vector>
#include "ash/root_window_controller.h"
#include "ash/wm/caption_buttons/frame_caption_button_container_view.h"
#include "ash/wm/solo_window_tracker.h"
#include "base/logging.h" // DCHECK
#include "grit/ash_resources.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkColor.h"
#include "third_party/skia/include/core/SkPaint.h"
#include "third_party/skia/include/core/SkPath.h"
#include "ui/aura/window.h"
#include "ui/base/hit_test.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/base/theme_provider.h"
#include "ui/gfx/animation/slide_animation.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/font.h"
#include "ui/gfx/image/image.h"
#include "ui/gfx/screen.h"
#include "ui/gfx/skia_util.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_delegate.h"
using aura::Window;
using views::Widget;
namespace {
// Space between left edge of window and popup window icon.
const int kIconOffsetX = 9;
// Height and width of window icon.
const int kIconSize = 16;
// Space between the title text and the caption buttons.
const int kTitleLogoSpacing = 5;
// Space between window icon and title text.
const int kTitleIconOffsetX = 5;
// Space between window edge and title text, when there is no icon.
const int kTitleNoIconOffsetX = 8;
// Color for the non-maximized window title text.
const SkColor kNonMaximizedWindowTitleTextColor = SkColorSetRGB(40, 40, 40);
// Color for the maximized window title text.
const SkColor kMaximizedWindowTitleTextColor = SK_ColorWHITE;
// Size of header/content separator line below the header image.
const int kHeaderContentSeparatorSize = 1;
// Color of header bottom edge line.
const SkColor kHeaderContentSeparatorColor = SkColorSetRGB(128, 128, 128);
// In the pre-Ash era the web content area had a frame along the left edge, so
// user-generated theme images for the new tab page assume they are shifted
// right relative to the header. Now that we have removed the left edge frame
// we need to copy the theme image for the window header from a few pixels
// inset to preserve alignment with the NTP image, or else we'll break a bunch
// of existing themes. We do something similar on OS X for the same reason.
const int kThemeFrameImageInsetX = 5;
// Duration of crossfade animation for activating and deactivating frame.
const int kActivationCrossfadeDurationMs = 200;
// Alpha/opacity value for fully-opaque headers.
const int kFullyOpaque = 255;
// Tiles an image into an area, rounding the top corners. Samples |image|
// starting |image_inset_x| pixels from the left of the image.
void TileRoundRect(gfx::Canvas* canvas,
const gfx::ImageSkia& image,
const SkPaint& paint,
const gfx::Rect& bounds,
int top_left_corner_radius,
int top_right_corner_radius,
int image_inset_x) {
SkRect rect = gfx::RectToSkRect(bounds);
const SkScalar kTopLeftRadius = SkIntToScalar(top_left_corner_radius);
const SkScalar kTopRightRadius = SkIntToScalar(top_right_corner_radius);
SkScalar radii[8] = {
kTopLeftRadius, kTopLeftRadius, // top-left
kTopRightRadius, kTopRightRadius, // top-right
0, 0, // bottom-right
0, 0}; // bottom-left
SkPath path;
path.addRoundRect(rect, radii, SkPath::kCW_Direction);
canvas->DrawImageInPath(image, -image_inset_x, 0, path, paint);
}
// Tiles |frame_image| and |frame_overlay_image| into an area, rounding the top
// corners.
void PaintFrameImagesInRoundRect(gfx::Canvas* canvas,
const gfx::ImageSkia* frame_image,
const gfx::ImageSkia* frame_overlay_image,
const SkPaint& paint,
const gfx::Rect& bounds,
int corner_radius,
int image_inset_x) {
SkXfermode::Mode normal_mode;
SkXfermode::AsMode(NULL, &normal_mode);
// If |paint| is using an unusual SkXfermode::Mode (this is the case while
// crossfading), we must create a new canvas to overlay |frame_image| and
// |frame_overlay_image| using |normal_mode| and then paint the result
// using the unusual mode. We try to avoid this because creating a new
// browser-width canvas is expensive.
bool fast_path = (!frame_overlay_image ||
SkXfermode::IsMode(paint.getXfermode(), normal_mode));
if (fast_path) {
TileRoundRect(canvas, *frame_image, paint, bounds, corner_radius,
corner_radius, image_inset_x);
if (frame_overlay_image) {
// Adjust |bounds| such that |frame_overlay_image| is not tiled.
gfx::Rect overlay_bounds = bounds;
overlay_bounds.Intersect(
gfx::Rect(bounds.origin(), frame_overlay_image->size()));
int top_left_corner_radius = corner_radius;
int top_right_corner_radius = corner_radius;
if (overlay_bounds.width() < bounds.width() - corner_radius)
top_right_corner_radius = 0;
TileRoundRect(canvas, *frame_overlay_image, paint, overlay_bounds,
top_left_corner_radius, top_right_corner_radius, 0);
}
} else {
gfx::Canvas temporary_canvas(bounds.size(), canvas->image_scale(), false);
temporary_canvas.TileImageInt(*frame_image,
image_inset_x, 0,
0, 0,
bounds.width(), bounds.height());
temporary_canvas.DrawImageInt(*frame_overlay_image, 0, 0);
TileRoundRect(canvas, gfx::ImageSkia(temporary_canvas.ExtractImageRep()),
paint, bounds, corner_radius, corner_radius, 0);
}
}
} // namespace
namespace ash {
// static
int HeaderPainter::kActiveWindowOpacity = 255; // 1.0
int HeaderPainter::kInactiveWindowOpacity = 255; // 1.0
int HeaderPainter::kSoloWindowOpacity = 77; // 0.3
///////////////////////////////////////////////////////////////////////////////
// HeaderPainter, public:
HeaderPainter::HeaderPainter()
: frame_(NULL),
header_view_(NULL),
window_icon_(NULL),
caption_button_container_(NULL),
window_(NULL),
header_height_(0),
top_left_corner_(NULL),
top_edge_(NULL),
top_right_corner_(NULL),
header_left_edge_(NULL),
header_right_edge_(NULL),
previous_theme_frame_id_(0),
previous_theme_frame_overlay_id_(0),
previous_opacity_(0),
crossfade_theme_frame_id_(0),
crossfade_theme_frame_overlay_id_(0),
crossfade_opacity_(0) {}
HeaderPainter::~HeaderPainter() {
// Sometimes we are destroyed before the window closes, so ensure we clean up.
if (window_)
window_->RemoveObserver(this);
}
void HeaderPainter::Init(
views::Widget* frame,
views::View* header_view,
views::View* window_icon,
FrameCaptionButtonContainerView* caption_button_container) {
DCHECK(frame);
DCHECK(header_view);
// window_icon may be NULL.
DCHECK(caption_button_container);
frame_ = frame;
header_view_ = header_view;
window_icon_ = window_icon;
caption_button_container_ = caption_button_container;
// Window frame image parts.
ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
top_left_corner_ =
rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP_LEFT).ToImageSkia();
top_edge_ =
rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP).ToImageSkia();
top_right_corner_ =
rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP_RIGHT).ToImageSkia();
header_left_edge_ =
rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_LEFT).ToImageSkia();
header_right_edge_ =
rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_RIGHT).ToImageSkia();
window_ = frame->GetNativeWindow();
// Observer removes itself in OnWindowDestroying() below, or in the destructor
// if we go away before the window.
window_->AddObserver(this);
// Solo-window header updates are handled by the WorkspaceLayoutManager when
// this window is added to the desktop.
}
// static
gfx::Rect HeaderPainter::GetBoundsForClientView(
int header_height,
const gfx::Rect& window_bounds) {
gfx::Rect client_bounds(window_bounds);
client_bounds.Inset(0, header_height, 0, 0);
return client_bounds;
}
// static
gfx::Rect HeaderPainter::GetWindowBoundsForClientBounds(
int header_height,
const gfx::Rect& client_bounds) {
gfx::Rect window_bounds(client_bounds);
window_bounds.Inset(0, -header_height, 0, 0);
if (window_bounds.y() < 0)
window_bounds.set_y(0);
return window_bounds;
}
int HeaderPainter::NonClientHitTest(const gfx::Point& point) const {
gfx::Point point_in_header_view(point);
views::View::ConvertPointFromWidget(header_view_, &point_in_header_view);
if (!GetHeaderLocalBounds().Contains(point_in_header_view))
return HTNOWHERE;
if (caption_button_container_->visible()) {
gfx::Point point_in_caption_button_container(point);
views::View::ConvertPointFromWidget(caption_button_container_,
&point_in_caption_button_container);
int component = caption_button_container_->NonClientHitTest(
point_in_caption_button_container);
if (component != HTNOWHERE)
return component;
}
// Caption is a safe default.
return HTCAPTION;
}
int HeaderPainter::GetMinimumHeaderWidth() const {
// Ensure we have enough space for the window icon and buttons. We allow
// the title string to collapse to zero width.
return GetTitleOffsetX() +
caption_button_container_->GetMinimumSize().width();
}
int HeaderPainter::GetRightInset() const {
return caption_button_container_->GetPreferredSize().width();
}
int HeaderPainter::GetThemeBackgroundXInset() const {
return kThemeFrameImageInsetX;
}
void HeaderPainter::PaintHeader(gfx::Canvas* canvas,
HeaderMode header_mode,
int theme_frame_id,
int theme_frame_overlay_id) {
bool initial_paint = (previous_theme_frame_id_ == 0);
if (!initial_paint &&
(previous_theme_frame_id_ != theme_frame_id ||
previous_theme_frame_overlay_id_ != theme_frame_overlay_id)) {
aura::Window* parent = frame_->GetNativeWindow()->parent();
// Don't animate the header if the parent (a workspace) is already
// animating. Doing so results in continually painting during the animation
// and gives a slower frame rate.
// TODO(sky): expose a better way to determine this rather than assuming
// the parent is a workspace.
bool parent_animating = parent &&
(parent->layer()->GetAnimator()->IsAnimatingProperty(
ui::LayerAnimationElement::OPACITY) ||
parent->layer()->GetAnimator()->IsAnimatingProperty(
ui::LayerAnimationElement::VISIBILITY));
if (!parent_animating) {
crossfade_animation_.reset(new gfx::SlideAnimation(this));
crossfade_theme_frame_id_ = previous_theme_frame_id_;
crossfade_theme_frame_overlay_id_ = previous_theme_frame_overlay_id_;
crossfade_opacity_ = previous_opacity_;
crossfade_animation_->SetSlideDuration(kActivationCrossfadeDurationMs);
crossfade_animation_->Show();
} else {
crossfade_animation_.reset();
}
}
int opacity =
GetHeaderOpacity(header_mode, theme_frame_id, theme_frame_overlay_id);
ui::ThemeProvider* theme_provider = frame_->GetThemeProvider();
gfx::ImageSkia* theme_frame = theme_provider->GetImageSkiaNamed(
theme_frame_id);
gfx::ImageSkia* theme_frame_overlay = NULL;
if (theme_frame_overlay_id != 0) {
theme_frame_overlay = theme_provider->GetImageSkiaNamed(
theme_frame_overlay_id);
}
int corner_radius = GetHeaderCornerRadius();
SkPaint paint;
if (crossfade_animation_.get() && crossfade_animation_->is_animating()) {
gfx::ImageSkia* crossfade_theme_frame =
theme_provider->GetImageSkiaNamed(crossfade_theme_frame_id_);
gfx::ImageSkia* crossfade_theme_frame_overlay = NULL;
if (crossfade_theme_frame_overlay_id_ != 0) {
crossfade_theme_frame_overlay = theme_provider->GetImageSkiaNamed(
crossfade_theme_frame_overlay_id_);
}
if (!crossfade_theme_frame ||
(crossfade_theme_frame_overlay_id_ != 0 &&
!crossfade_theme_frame_overlay)) {
// Reset the animation. This case occurs when the user switches the theme
// that they are using.
crossfade_animation_.reset();
paint.setAlpha(opacity);
} else {
double current_value = crossfade_animation_->GetCurrentValue();
int old_alpha = (1 - current_value) * crossfade_opacity_;
int new_alpha = current_value * opacity;
// Draw the old header background, clipping the corners to be rounded.
paint.setAlpha(old_alpha);
paint.setXfermodeMode(SkXfermode::kPlus_Mode);
PaintFrameImagesInRoundRect(canvas,
crossfade_theme_frame,
crossfade_theme_frame_overlay,
paint,
GetHeaderLocalBounds(),
corner_radius,
GetThemeBackgroundXInset());
paint.setAlpha(new_alpha);
}
} else {
paint.setAlpha(opacity);
}
// Draw the header background, clipping the corners to be rounded.
PaintFrameImagesInRoundRect(canvas,
theme_frame,
theme_frame_overlay,
paint,
GetHeaderLocalBounds(),
corner_radius,
GetThemeBackgroundXInset());
previous_theme_frame_id_ = theme_frame_id;
previous_theme_frame_overlay_id_ = theme_frame_overlay_id;
previous_opacity_ = opacity;
// We don't need the extra lightness in the edges when we're at the top edge
// of the screen or when the header's corners are not rounded.
//
// TODO(sky): this isn't quite right. What we really want is a method that
// returns bounds ignoring transforms on certain windows (such as workspaces)
// and is relative to the root.
if (frame_->GetNativeWindow()->bounds().y() == 0 || corner_radius == 0)
return;
// Draw the top corners and edge.
int top_left_width = top_left_corner_->width();
int top_left_height = top_left_corner_->height();
canvas->DrawImageInt(*top_left_corner_,
0, 0, top_left_width, top_left_height,
0, 0, top_left_width, top_left_height,
false);
canvas->TileImageInt(*top_edge_,
top_left_width,
0,
header_view_->width() - top_left_width - top_right_corner_->width(),
top_edge_->height());
int top_right_height = top_right_corner_->height();
canvas->DrawImageInt(*top_right_corner_,
0, 0,
top_right_corner_->width(), top_right_height,
header_view_->width() - top_right_corner_->width(), 0,
top_right_corner_->width(), top_right_height,
false);
// Header left edge.
int header_left_height = theme_frame->height() - top_left_height;
canvas->TileImageInt(*header_left_edge_,
0, top_left_height,
header_left_edge_->width(), header_left_height);
// Header right edge.
int header_right_height = theme_frame->height() - top_right_height;
canvas->TileImageInt(*header_right_edge_,
header_view_->width() - header_right_edge_->width(),
top_right_height,
header_right_edge_->width(),
header_right_height);
// We don't draw edges around the content area. Web content goes flush
// to the edge of the window.
}
void HeaderPainter::PaintHeaderContentSeparator(gfx::Canvas* canvas) {
canvas->FillRect(gfx::Rect(0,
header_height_ - kHeaderContentSeparatorSize,
header_view_->width(),
kHeaderContentSeparatorSize),
kHeaderContentSeparatorColor);
}
int HeaderPainter::HeaderContentSeparatorSize() const {
return kHeaderContentSeparatorSize;
}
void HeaderPainter::PaintTitleBar(gfx::Canvas* canvas,
const gfx::Font& title_font) {
// The window icon is painted by its own views::View.
views::WidgetDelegate* delegate = frame_->widget_delegate();
if (delegate && delegate->ShouldShowWindowTitle()) {
gfx::Rect title_bounds = GetTitleBounds(title_font);
SkColor title_color = (frame_->IsMaximized() || frame_->IsFullscreen()) ?
kMaximizedWindowTitleTextColor : kNonMaximizedWindowTitleTextColor;
canvas->DrawStringInt(delegate->GetWindowTitle(),
title_font,
title_color,
header_view_->GetMirroredXForRect(title_bounds),
title_bounds.y(),
title_bounds.width(),
title_bounds.height(),
gfx::Canvas::NO_SUBPIXEL_RENDERING);
}
}
void HeaderPainter::LayoutHeader(bool shorter_layout) {
caption_button_container_->set_header_style(shorter_layout ?
FrameCaptionButtonContainerView::HEADER_STYLE_SHORT :
FrameCaptionButtonContainerView::HEADER_STYLE_TALL);
caption_button_container_->Layout();
gfx::Size caption_button_container_size =
caption_button_container_->GetPreferredSize();
caption_button_container_->SetBounds(
header_view_->width() - caption_button_container_size.width(),
0,
caption_button_container_size.width(),
caption_button_container_size.height());
if (window_icon_) {
// Vertically center the window icon with respect to the caption button
// container.
int icon_offset_y =
GetCaptionButtonContainerCenterY() - window_icon_->height() / 2;
window_icon_->SetBounds(kIconOffsetX, icon_offset_y, kIconSize, kIconSize);
}
}
void HeaderPainter::SchedulePaintForTitle(const gfx::Font& title_font) {
header_view_->SchedulePaintInRect(GetTitleBounds(title_font));
}
void HeaderPainter::OnThemeChanged() {
// We do not cache the images for |previous_theme_frame_id_| and
// |previous_theme_frame_overlay_id_|. Changing the theme changes the images
// returned from ui::ThemeProvider for |previous_theme_frame_id_|
// and |previous_theme_frame_overlay_id_|. Reset the image ids to prevent
// starting a crossfade animation with these images.
previous_theme_frame_id_ = 0;
previous_theme_frame_overlay_id_ = 0;
if (crossfade_animation_.get() && crossfade_animation_->is_animating()) {
crossfade_animation_.reset();
header_view_->SchedulePaintInRect(GetHeaderLocalBounds());
}
}
///////////////////////////////////////////////////////////////////////////////
// aura::WindowObserver overrides:
void HeaderPainter::OnWindowDestroying(aura::Window* destroying) {
DCHECK_EQ(window_, destroying);
// Must be removed here and not in the destructor, as the aura::Window is
// already destroyed when our destructor runs.
window_->RemoveObserver(this);
window_ = NULL;
}
void HeaderPainter::OnWindowBoundsChanged(aura::Window* window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds) {
// TODO(sky): this isn't quite right. What we really want is a method that
// returns bounds ignoring transforms on certain windows (such as workspaces).
if ((!frame_->IsMaximized() && !frame_->IsFullscreen()) &&
((old_bounds.y() == 0 && new_bounds.y() != 0) ||
(old_bounds.y() != 0 && new_bounds.y() == 0))) {
SchedulePaintForHeader();
}
}
///////////////////////////////////////////////////////////////////////////////
// gfx::AnimationDelegate overrides:
void HeaderPainter::AnimationProgressed(const gfx::Animation* animation) {
header_view_->SchedulePaintInRect(GetHeaderLocalBounds());
}
///////////////////////////////////////////////////////////////////////////////
// HeaderPainter, private:
gfx::Rect HeaderPainter::GetHeaderLocalBounds() const {
return gfx::Rect(header_view_->width(), header_height_);
}
int HeaderPainter::GetTitleOffsetX() const {
return window_icon_ ?
window_icon_->bounds().right() + kTitleIconOffsetX :
kTitleNoIconOffsetX;
}
int HeaderPainter::GetCaptionButtonContainerCenterY() const {
return caption_button_container_->y() +
caption_button_container_->height() / 2;
}
int HeaderPainter::GetHeaderCornerRadius() const {
bool square_corners = (frame_->IsMaximized() || frame_->IsFullscreen());
const int kCornerRadius = 2;
return square_corners ? 0 : kCornerRadius;
}
int HeaderPainter::GetHeaderOpacity(
HeaderMode header_mode,
int theme_frame_id,
int theme_frame_overlay_id) const {
// User-provided themes are painted fully opaque.
ui::ThemeProvider* theme_provider = frame_->GetThemeProvider();
if (theme_provider->HasCustomImage(theme_frame_id) ||
(theme_frame_overlay_id != 0 &&
theme_provider->HasCustomImage(theme_frame_overlay_id))) {
return kFullyOpaque;
}
// Maximized and fullscreen windows are fully opaque.
if (frame_->IsMaximized() || frame_->IsFullscreen())
return kFullyOpaque;
// Solo header is very transparent.
ash::SoloWindowTracker* solo_window_tracker =
internal::RootWindowController::ForWindow(window_)->solo_window_tracker();
if (solo_window_tracker &&
solo_window_tracker->GetWindowWithSoloHeader() == window_) {
return kSoloWindowOpacity;
}
// Otherwise, change transparency based on window activation status.
if (header_mode == ACTIVE)
return kActiveWindowOpacity;
return kInactiveWindowOpacity;
}
void HeaderPainter::SchedulePaintForHeader() {
int top_left_height = top_left_corner_->height();
int top_right_height = top_right_corner_->height();
header_view_->SchedulePaintInRect(
gfx::Rect(0, 0, header_view_->width(),
std::max(top_left_height, top_right_height)));
}
gfx::Rect HeaderPainter::GetTitleBounds(const gfx::Font& title_font) {
int title_x = GetTitleOffsetX();
// Center the text with respect to the caption button container. This way it
// adapts to the caption button height and aligns exactly with the window
// icon. Don't use |window_icon_| for this computation as it may be NULL.
int title_y = GetCaptionButtonContainerCenterY() - title_font.GetHeight() / 2;
return gfx::Rect(
title_x,
std::max(0, title_y),
std::max(0, caption_button_container_->x() - kTitleLogoSpacing - title_x),
title_font.GetHeight());
}
} // namespace ash