// 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 #include "ash/wm/caption_buttons/frame_caption_button_container_view.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_list.h" #include "ui/gfx/image/image.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 for non-browser // windows. const int kHeaderContentSeparatorSize = 1; // Color of the active window header/content separator line for non-browser // windows. const SkColor kHeaderContentSeparatorColor = SkColorSetRGB(180, 180, 182); // Color of the inactive window header/content separator line for non-browser // windows. const SkColor kHeaderContentSeparatorInactiveColor = SkColorSetRGB(150, 150, 152); // 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; // 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 { /////////////////////////////////////////////////////////////////////////////// // HeaderPainter, public: HeaderPainter::HeaderPainter() : frame_(NULL), header_view_(NULL), window_icon_(NULL), caption_button_container_(NULL), header_height_(0), previous_theme_frame_id_(0), previous_theme_frame_overlay_id_(0), crossfade_theme_frame_id_(0), crossfade_theme_frame_overlay_id_(0) {} HeaderPainter::~HeaderPainter() { } void HeaderPainter::Init( Style style, 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); style_ = style; frame_ = frame; header_view_ = header_view; window_icon_ = window_icon; caption_button_container_ = caption_button_container; } // 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); 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, Mode 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_animation_->SetSlideDuration(kActivationCrossfadeDurationMs); crossfade_animation_->Show(); } else { crossfade_animation_.reset(); } } 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(); } else { int old_alpha = crossfade_animation_->CurrentValueBetween(255, 0); int new_alpha = 255 - old_alpha; // 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); } } // 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; PaintBorder(canvas, mode); } void HeaderPainter::PaintHeaderContentSeparator(gfx::Canvas* canvas, Mode mode) { DCHECK_EQ(style_, STYLE_OTHER); SkColor color = (mode == MODE_ACTIVE) ? kHeaderContentSeparatorColor : kHeaderContentSeparatorInactiveColor; canvas->FillRect(gfx::Rect(0, header_height_ - kHeaderContentSeparatorSize, header_view_->width(), kHeaderContentSeparatorSize), color); } int HeaderPainter::HeaderContentSeparatorSize() const { return kHeaderContentSeparatorSize; } void HeaderPainter::PaintTitleBar(gfx::Canvas* canvas, const gfx::FontList& title_font_list) { // 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_list); title_bounds.set_x(header_view_->GetMirroredXForRect(title_bounds)); SkColor title_color = (frame_->IsMaximized() || frame_->IsFullscreen()) ? kMaximizedWindowTitleTextColor : kNonMaximizedWindowTitleTextColor; canvas->DrawStringRectWithFlags(delegate->GetWindowTitle(), title_font_list, title_color, title_bounds, gfx::Canvas::NO_SUBPIXEL_RENDERING); } } void HeaderPainter::LayoutHeader() { // Purposefully set |header_height_| to an invalid value. We cannot use // |header_height_| because the computation of |header_height_| may depend // on having laid out the window controls. header_height_ = -1; UpdateCaptionButtonImages(); 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::FontList& title_font_list) { header_view_->SchedulePaintInRect(GetTitleBounds(title_font_list)); } 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()); } } /////////////////////////////////////////////////////////////////////////////// // gfx::AnimationDelegate overrides: void HeaderPainter::AnimationProgressed(const gfx::Animation* animation) { header_view_->SchedulePaintInRect(GetHeaderLocalBounds()); } /////////////////////////////////////////////////////////////////////////////// // HeaderPainter, private: void HeaderPainter::PaintBorder(gfx::Canvas* canvas, Mode mode) { if (frame_->IsMaximized() || frame_->IsFullscreen() || (style_ == STYLE_OTHER && mode == MODE_ACTIVE)) { return; } gfx::ImageSkia top_left_corner; gfx::ImageSkia top_right_corner; gfx::ImageSkia top_edge; gfx::ImageSkia left_edge; gfx::ImageSkia right_edge; gfx::ImageSkia bottom_edge; ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); if (style_ == STYLE_BROWSER) { top_left_corner = *rb.GetImageSkiaNamed( IDR_AURA_BROWSER_WINDOW_HEADER_SHADE_TOP_LEFT); top_right_corner = *rb.GetImageSkiaNamed( IDR_AURA_BROWSER_WINDOW_HEADER_SHADE_TOP_RIGHT); top_edge = *rb.GetImageSkiaNamed(IDR_AURA_BROWSER_WINDOW_HEADER_SHADE_TOP); left_edge = *rb.GetImageSkiaNamed( IDR_AURA_BROWSER_WINDOW_HEADER_SHADE_LEFT); right_edge = *rb.GetImageSkiaNamed( IDR_AURA_BROWSER_WINDOW_HEADER_SHADE_RIGHT); } else { top_edge = *rb.GetImageSkiaNamed( IDR_AURA_WINDOW_HEADER_SHADE_INACTIVE_TOP); left_edge = *rb.GetImageSkiaNamed( IDR_AURA_WINDOW_HEADER_SHADE_INACTIVE_LEFT); right_edge = *rb.GetImageSkiaNamed( IDR_AURA_WINDOW_HEADER_SHADE_INACTIVE_RIGHT); bottom_edge = *rb.GetImageSkiaNamed( IDR_AURA_WINDOW_HEADER_SHADE_INACTIVE_BOTTOM); } DCHECK(!top_edge.isNull()); DCHECK(!left_edge.isNull()); DCHECK(!right_edge.isNull()); int top_left_width = top_left_corner.width(); int top_left_height = top_left_corner.height(); if (!top_left_corner.isNull()) { canvas->DrawImageInt(top_left_corner, 0, 0); } int top_right_height = top_right_corner.height(); if (!top_right_corner.isNull()) { canvas->DrawImageInt(top_right_corner, header_view_->width() - top_right_corner.width(), top_right_height); } canvas->TileImageInt(top_edge, top_left_width, 0, header_view_->width() - top_left_width - top_right_corner.width(), top_edge.height()); // TODO(pkotwicz): Compute |bottom| more accurately. The computation is // inaccurate for browser windows. int bottom = header_height_ - kHeaderContentSeparatorSize; int bottom_height = bottom_edge.height(); if (!bottom_edge.isNull()) { canvas->TileImageInt(bottom_edge, 0, bottom - bottom_height, header_view_->width(), bottom_height); } int left_edge_height = bottom - bottom_height - top_left_height; canvas->TileImageInt(left_edge, 0, top_left_height, left_edge.width(), left_edge_height); int right_edge_height = bottom - bottom_height - top_right_height; canvas->TileImageInt(right_edge, header_view_->width() - right_edge.width(), top_right_height, right_edge.width(), right_edge_height); } void HeaderPainter::UpdateCaptionButtonImages() { if (style_ == STYLE_BROWSER) { if (frame_->IsMaximized() || frame_->IsFullscreen()) { caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_MINIMIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_MINIMIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_MINIMIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_MAXIMIZE_RESTORE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_SIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_SIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_CLOSE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_CLOSE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_CLOSE, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_LEFT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_LEFT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_LEFT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_RIGHT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_RIGHT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_MAXIMIZED_RIGHT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_P); } else { caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_MINIMIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_MINIMIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_MINIMIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_MAXIMIZE_RESTORE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_SIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_SIZE, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_CLOSE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_CLOSE, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_CLOSE, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_LEFT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_LEFT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_LEFT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_RIGHT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_RIGHT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_ICON_RESTORED_RIGHT_SNAPPED, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_H, IDR_AURA_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_P); } } else { caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_MINIMIZE, IDR_AURA_WINDOW_CONTROL_ICON_MINIMIZE, IDR_AURA_WINDOW_CONTROL_ICON_MINIMIZE_I, IDR_AURA_WINDOW_CONTROL_BACKGROUND_H, IDR_AURA_WINDOW_CONTROL_BACKGROUND_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_MAXIMIZE_RESTORE, IDR_AURA_WINDOW_CONTROL_ICON_SIZE, IDR_AURA_WINDOW_CONTROL_ICON_SIZE_I, IDR_AURA_WINDOW_CONTROL_BACKGROUND_H, IDR_AURA_WINDOW_CONTROL_BACKGROUND_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_CLOSE, IDR_AURA_WINDOW_CONTROL_ICON_CLOSE, IDR_AURA_WINDOW_CONTROL_ICON_CLOSE_I, IDR_AURA_WINDOW_CONTROL_BACKGROUND_H, IDR_AURA_WINDOW_CONTROL_BACKGROUND_P); // There is no dedicated icon for the snap-left and snap-right buttons // when |frame_| is inactive because they should never be visible while // |frame_| is inactive. caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_LEFT_SNAPPED, IDR_AURA_WINDOW_CONTROL_ICON_LEFT_SNAPPED, IDR_AURA_WINDOW_CONTROL_ICON_LEFT_SNAPPED, IDR_AURA_WINDOW_CONTROL_BACKGROUND_H, IDR_AURA_WINDOW_CONTROL_BACKGROUND_P); caption_button_container_->SetButtonImages( CAPTION_BUTTON_ICON_RIGHT_SNAPPED, IDR_AURA_WINDOW_CONTROL_ICON_RIGHT_SNAPPED, IDR_AURA_WINDOW_CONTROL_ICON_RIGHT_SNAPPED, IDR_AURA_WINDOW_CONTROL_BACKGROUND_H, IDR_AURA_WINDOW_CONTROL_BACKGROUND_P); } } 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; } gfx::Rect HeaderPainter::GetTitleBounds(const gfx::FontList& title_font_list) { 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_list.GetHeight() / 2; return gfx::Rect( title_x, std::max(0, title_y), std::max(0, caption_button_container_->x() - kTitleLogoSpacing - title_x), title_font_list.GetHeight()); } } // namespace ash