chrome/browser/ui/views/frame/browser_header_painter_ash.cc

   1 // Copyright 2014 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 "chrome/browser/ui/views/frame/browser_header_painter_ash.h"
   6
   7 #include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
   8 #include "ash/frame/header_painter_util.h"
   9 #include "base/logging.h"  // DCHECK
  10 #include "chrome/browser/ui/browser.h"
  11 #include "chrome/browser/ui/views/frame/browser_frame.h"
  12 #include "chrome/browser/ui/views/frame/browser_view.h"
  13 #include "grit/theme_resources.h"
  14 #include "third_party/skia/include/core/SkCanvas.h"
  15 #include "third_party/skia/include/core/SkColor.h"
  16 #include "third_party/skia/include/core/SkPaint.h"
  17 #include "third_party/skia/include/core/SkPath.h"
  18 #include "ui/base/resource/resource_bundle.h"
  19 #include "ui/base/theme_provider.h"
  20 #include "ui/gfx/animation/slide_animation.h"
  21 #include "ui/gfx/canvas.h"
  22 #include "ui/gfx/image/image_skia.h"
  23 #include "ui/gfx/rect.h"
  24 #include "ui/gfx/skia_util.h"
  25 #include "ui/views/view.h"
  26 #include "ui/views/widget/widget.h"
  27 #include "ui/views/widget/widget_delegate.h"
  28
  29 using views::Widget;
  30
  31 namespace {
  32 // Color for the window title text.
  33 const SkColor kWindowTitleTextColor = SkColorSetRGB(40, 40, 40);
  34 // Duration of crossfade animation for activating and deactivating frame.
  35 const int kActivationCrossfadeDurationMs = 200;
  36
  37 // Tiles an image into an area, rounding the top corners. Samples |image|
  38 // starting |image_inset_x| pixels from the left of the image.
  39 void TileRoundRect(gfx::Canvas* canvas,
  40                    const gfx::ImageSkia& image,
  41                    const SkPaint& paint,
  42                    const gfx::Rect& bounds,
  43                    int top_left_corner_radius,
  44                    int top_right_corner_radius,
  45                    int image_inset_x) {
  46   SkRect rect = gfx::RectToSkRect(bounds);
  47   const SkScalar kTopLeftRadius = SkIntToScalar(top_left_corner_radius);
  48   const SkScalar kTopRightRadius = SkIntToScalar(top_right_corner_radius);
  49   SkScalar radii[8] = {
  50       kTopLeftRadius, kTopLeftRadius,  // top-left
  51       kTopRightRadius, kTopRightRadius,  // top-right
  52       0, 0,   // bottom-right
  53       0, 0};  // bottom-left
  54   SkPath path;
  55   path.addRoundRect(rect, radii, SkPath::kCW_Direction);
  56   canvas->DrawImageInPath(image, -image_inset_x, 0, path, paint);
  57 }
  58
  59 // Tiles |frame_image| and |frame_overlay_image| into an area, rounding the top
  60 // corners.
  61 void PaintFrameImagesInRoundRect(gfx::Canvas* canvas,
  62                                  const gfx::ImageSkia& frame_image,
  63                                  const gfx::ImageSkia& frame_overlay_image,
  64                                  const SkPaint& paint,
  65                                  const gfx::Rect& bounds,
  66                                  int corner_radius,
  67                                  int image_inset_x) {
  68   SkXfermode::Mode normal_mode;
  69   SkXfermode::AsMode(NULL, &normal_mode);
  70
  71   // If |paint| is using an unusual SkXfermode::Mode (this is the case while
  72   // crossfading), we must create a new canvas to overlay |frame_image| and
  73   // |frame_overlay_image| using |normal_mode| and then paint the result
  74   // using the unusual mode. We try to avoid this because creating a new
  75   // browser-width canvas is expensive.
  76   bool fast_path = (frame_overlay_image.isNull() ||
  77       SkXfermode::IsMode(paint.getXfermode(), normal_mode));
  78   if (fast_path) {
  79     TileRoundRect(canvas, frame_image, paint, bounds, corner_radius,
  80         corner_radius, image_inset_x);
  81
  82     if (!frame_overlay_image.isNull()) {
  83       // Adjust |bounds| such that |frame_overlay_image| is not tiled.
  84       gfx::Rect overlay_bounds = bounds;
  85       overlay_bounds.Intersect(
  86           gfx::Rect(bounds.origin(), frame_overlay_image.size()));
  87       int top_left_corner_radius = corner_radius;
  88       int top_right_corner_radius = corner_radius;
  89       if (overlay_bounds.width() < bounds.width() - corner_radius)
  90         top_right_corner_radius = 0;
  91       TileRoundRect(canvas, frame_overlay_image, paint, overlay_bounds,
  92           top_left_corner_radius, top_right_corner_radius, 0);
  93     }
  94   } else {
  95     gfx::Canvas temporary_canvas(bounds.size(), canvas->image_scale(), false);
  96     temporary_canvas.TileImageInt(frame_image,
  97                                   image_inset_x, 0,
  98                                   0, 0,
  99                                   bounds.width(), bounds.height());
 100     temporary_canvas.DrawImageInt(frame_overlay_image, 0, 0);
 101     TileRoundRect(canvas, gfx::ImageSkia(temporary_canvas.ExtractImageRep()),
 102         paint, bounds, corner_radius, corner_radius, 0);
 103   }
 104 }
 105
 106 }  // namespace
 107
 108 ///////////////////////////////////////////////////////////////////////////////
 109 // BrowserHeaderPainterAsh, public:
 110
 111 BrowserHeaderPainterAsh::BrowserHeaderPainterAsh()
 112     : frame_(NULL),
 113       is_tabbed_(false),
 114       is_incognito_(false),
 115       view_(NULL),
 116       window_icon_(NULL),
 117       caption_button_container_(NULL),
 118       painted_height_(0),
 119       initial_paint_(true),
 120       mode_(MODE_INACTIVE),
 121       activation_animation_(new gfx::SlideAnimation(this)) {
 122 }
 123
 124 BrowserHeaderPainterAsh::~BrowserHeaderPainterAsh() {
 125 }
 126
 127 void BrowserHeaderPainterAsh::Init(
 128     views::Widget* frame,
 129     BrowserView* browser_view,
 130     views::View* header_view,
 131     views::View* window_icon,
 132     ash::FrameCaptionButtonContainerView* caption_button_container) {
 133   DCHECK(frame);
 134   DCHECK(browser_view);
 135   DCHECK(header_view);
 136   // window_icon may be NULL.
 137   DCHECK(caption_button_container);
 138   frame_ = frame;
 139
 140   is_tabbed_ = browser_view->browser()->is_type_tabbed();
 141   is_incognito_ = !browser_view->IsRegularOrGuestSession();
 142
 143   view_ = header_view;
 144   window_icon_ = window_icon;
 145   caption_button_container_ = caption_button_container;
 146 }
 147
 148 int BrowserHeaderPainterAsh::GetMinimumHeaderWidth() const {
 149   // Ensure we have enough space for the window icon and buttons. We allow
 150   // the title string to collapse to zero width.
 151   return GetTitleBounds().x() +
 152       caption_button_container_->GetMinimumSize().width();
 153 }
 154
 155 void BrowserHeaderPainterAsh::PaintHeader(gfx::Canvas* canvas, Mode mode) {
 156   Mode old_mode = mode_;
 157   mode_ = mode;
 158
 159   if (mode_ != old_mode) {
 160     if (!initial_paint_ &&
 161         ash::HeaderPainterUtil::CanAnimateActivation(frame_)) {
 162       activation_animation_->SetSlideDuration(kActivationCrossfadeDurationMs);
 163       if (mode_ == MODE_ACTIVE)
 164         activation_animation_->Show();
 165       else
 166         activation_animation_->Hide();
 167     } else {
 168       if (mode_ == MODE_ACTIVE)
 169         activation_animation_->Reset(1);
 170       else
 171         activation_animation_->Reset(0);
 172     }
 173     initial_paint_ = false;
 174   }
 175
 176   int corner_radius = (frame_->IsMaximized() || frame_->IsFullscreen()) ?
 177       0 : ash::HeaderPainterUtil::GetTopCornerRadiusWhenRestored();
 178
 179   int active_alpha = activation_animation_->CurrentValueBetween(0, 255);
 180   int inactive_alpha = 255 - active_alpha;
 181
 182   SkPaint paint;
 183   if (inactive_alpha > 0) {
 184     if (active_alpha > 0)
 185       paint.setXfermodeMode(SkXfermode::kPlus_Mode);
 186
 187     gfx::ImageSkia inactive_frame_image;
 188     gfx::ImageSkia inactive_frame_overlay_image;
 189     GetFrameImages(MODE_INACTIVE, &inactive_frame_image,
 190         &inactive_frame_overlay_image);
 191
 192     paint.setAlpha(inactive_alpha);
 193     PaintFrameImagesInRoundRect(
 194         canvas,
 195         inactive_frame_image,
 196         inactive_frame_overlay_image,
 197         paint,
 198         GetPaintedBounds(),
 199         corner_radius,
 200         ash::HeaderPainterUtil::GetThemeBackgroundXInset());
 201   }
 202
 203   if (active_alpha > 0) {
 204     gfx::ImageSkia active_frame_image;
 205     gfx::ImageSkia active_frame_overlay_image;
 206     GetFrameImages(MODE_ACTIVE, &active_frame_image,
 207         &active_frame_overlay_image);
 208
 209     paint.setAlpha(active_alpha);
 210     PaintFrameImagesInRoundRect(
 211         canvas,
 212         active_frame_image,
 213         active_frame_overlay_image,
 214         paint,
 215         GetPaintedBounds(),
 216         corner_radius,
 217         ash::HeaderPainterUtil::GetThemeBackgroundXInset());
 218   }
 219
 220   if (!frame_->IsMaximized() && !frame_->IsFullscreen())
 221     PaintHighlightForRestoredWindow(canvas);
 222   if (frame_->widget_delegate() &&
 223       frame_->widget_delegate()->ShouldShowWindowTitle()) {
 224     PaintTitleBar(canvas);
 225   }
 226 }
 227
 228 void BrowserHeaderPainterAsh::LayoutHeader() {
 229   // Purposefully set |painted_height_| to an invalid value. We cannot use
 230   // |painted_height_| because the computation of |painted_height_| may depend
 231   // on having laid out the window controls.
 232   painted_height_ = -1;
 233
 234   UpdateCaptionButtonImages();
 235   caption_button_container_->Layout();
 236
 237   gfx::Size caption_button_container_size =
 238       caption_button_container_->GetPreferredSize();
 239   caption_button_container_->SetBounds(
 240       view_->width() - caption_button_container_size.width(),
 241       0,
 242       caption_button_container_size.width(),
 243       caption_button_container_size.height());
 244
 245   if (window_icon_) {
 246     // Vertically center the window icon with respect to the caption button
 247     // container.
 248     int icon_size = ash::HeaderPainterUtil::GetDefaultIconSize();
 249     int icon_offset_y = (caption_button_container_->height() - icon_size) / 2;
 250     window_icon_->SetBounds(ash::HeaderPainterUtil::GetIconXOffset(),
 251         icon_offset_y, icon_size, icon_size);
 252   }
 253 }
 254
 255 int BrowserHeaderPainterAsh::GetHeaderHeightForPainting() const {
 256   return painted_height_;
 257 }
 258
 259 void BrowserHeaderPainterAsh::SetHeaderHeightForPainting(int height) {
 260   painted_height_ = height;
 261 }
 262
 263 void BrowserHeaderPainterAsh::SchedulePaintForTitle() {
 264   view_->SchedulePaintInRect(GetTitleBounds());
 265 }
 266
 267 ///////////////////////////////////////////////////////////////////////////////
 268 // gfx::AnimationDelegate overrides:
 269
 270 void BrowserHeaderPainterAsh::AnimationProgressed(
 271     const gfx::Animation* animation) {
 272   view_->SchedulePaintInRect(GetPaintedBounds());
 273 }
 274
 275 ///////////////////////////////////////////////////////////////////////////////
 276 // BrowserHeaderPainterAsh, private:
 277
 278 void BrowserHeaderPainterAsh::PaintHighlightForRestoredWindow(
 279     gfx::Canvas* canvas) {
 280   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 281   gfx::ImageSkia top_left_corner = *rb.GetImageSkiaNamed(
 282       IDR_ASH_BROWSER_WINDOW_HEADER_SHADE_TOP_LEFT);
 283   gfx::ImageSkia top_right_corner = *rb.GetImageSkiaNamed(
 284       IDR_ASH_BROWSER_WINDOW_HEADER_SHADE_TOP_RIGHT);
 285   gfx::ImageSkia top_edge = *rb.GetImageSkiaNamed(
 286       IDR_ASH_BROWSER_WINDOW_HEADER_SHADE_TOP);
 287   gfx::ImageSkia left_edge = *rb.GetImageSkiaNamed(
 288       IDR_ASH_BROWSER_WINDOW_HEADER_SHADE_LEFT);
 289   gfx::ImageSkia right_edge = *rb.GetImageSkiaNamed(
 290       IDR_ASH_BROWSER_WINDOW_HEADER_SHADE_RIGHT);
 291
 292   int top_left_width = top_left_corner.width();
 293   int top_left_height = top_left_corner.height();
 294   canvas->DrawImageInt(top_left_corner, 0, 0);
 295
 296   int top_right_width = top_right_corner.width();
 297   int top_right_height = top_right_corner.height();
 298   canvas->DrawImageInt(top_right_corner,
 299                        view_->width() - top_right_width,
 300                        0);
 301
 302   canvas->TileImageInt(
 303       top_edge,
 304       top_left_width,
 305       0,
 306       view_->width() - top_left_width - top_right_width,
 307       top_edge.height());
 308
 309   canvas->TileImageInt(left_edge,
 310                        0,
 311                        top_left_height,
 312                        left_edge.width(),
 313                        painted_height_ - top_left_height);
 314
 315   canvas->TileImageInt(right_edge,
 316                        view_->width() - right_edge.width(),
 317                        top_right_height,
 318                        right_edge.width(),
 319                        painted_height_ - top_right_height);
 320 }
 321
 322 void BrowserHeaderPainterAsh::PaintTitleBar(gfx::Canvas* canvas) {
 323   // The window icon is painted by its own views::View.
 324   gfx::Rect title_bounds = GetTitleBounds();
 325   title_bounds.set_x(view_->GetMirroredXForRect(title_bounds));
 326   canvas->DrawStringRectWithFlags(frame_->widget_delegate()->GetWindowTitle(),
 327                                   BrowserFrame::GetTitleFontList(),
 328                                   kWindowTitleTextColor,
 329                                   title_bounds,
 330                                   gfx::Canvas::NO_SUBPIXEL_RENDERING);
 331 }
 332
 333 void BrowserHeaderPainterAsh::GetFrameImages(
 334     Mode mode,
 335     gfx::ImageSkia* frame_image,
 336     gfx::ImageSkia* frame_overlay_image) const {
 337   if (is_tabbed_) {
 338     GetFrameImagesForTabbedBrowser(mode, frame_image, frame_overlay_image);
 339   } else {
 340     *frame_image = GetFrameImageForNonTabbedBrowser(mode);
 341     *frame_overlay_image = gfx::ImageSkia();
 342   }
 343 }
 344
 345 void BrowserHeaderPainterAsh::GetFrameImagesForTabbedBrowser(
 346     Mode mode,
 347     gfx::ImageSkia* frame_image,
 348     gfx::ImageSkia* frame_overlay_image) const {
 349   int frame_image_id = 0;
 350   int frame_overlay_image_id = 0;
 351
 352   ui::ThemeProvider* tp = frame_->GetThemeProvider();
 353   if (tp->HasCustomImage(IDR_THEME_FRAME_OVERLAY) && !is_incognito_) {
 354     frame_overlay_image_id = (mode == MODE_ACTIVE) ?
 355         IDR_THEME_FRAME_OVERLAY : IDR_THEME_FRAME_OVERLAY_INACTIVE;
 356   }
 357
 358   if (mode == MODE_ACTIVE) {
 359     frame_image_id = is_incognito_ ?
 360         IDR_THEME_FRAME_INCOGNITO : IDR_THEME_FRAME;
 361   } else {
 362     frame_image_id = is_incognito_ ?
 363         IDR_THEME_FRAME_INCOGNITO_INACTIVE : IDR_THEME_FRAME_INACTIVE;
 364   }
 365
 366   *frame_image = *tp->GetImageSkiaNamed(frame_image_id);
 367   *frame_overlay_image = (frame_overlay_image_id == 0) ?
 368       gfx::ImageSkia() : *tp->GetImageSkiaNamed(frame_overlay_image_id);
 369 }
 370
 371 gfx::ImageSkia BrowserHeaderPainterAsh::GetFrameImageForNonTabbedBrowser(
 372     Mode mode) const {
 373   // Request the images from the ResourceBundle (and not from the ThemeProvider)
 374   // in order to get the default non-themed assets.
 375   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 376   if (mode == MODE_ACTIVE) {
 377     return *rb.GetImageSkiaNamed(is_incognito_ ?
 378         IDR_THEME_FRAME_INCOGNITO : IDR_THEME_FRAME);
 379   }
 380   return *rb.GetImageSkiaNamed(is_incognito_ ?
 381       IDR_THEME_FRAME_INCOGNITO_INACTIVE : IDR_THEME_FRAME_INACTIVE);
 382 }
 383
 384 void BrowserHeaderPainterAsh::UpdateCaptionButtonImages() {
 385   int hover_background_id = 0;
 386   int pressed_background_id = 0;
 387   if (frame_->IsMaximized() || frame_->IsFullscreen()) {
 388     hover_background_id =
 389         IDR_ASH_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_H;
 390     pressed_background_id =
 391         IDR_ASH_BROWSER_WINDOW_CONTROL_BACKGROUND_MAXIMIZED_P;
 392   } else {
 393     hover_background_id =
 394         IDR_ASH_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_H;
 395     pressed_background_id =
 396         IDR_ASH_BROWSER_WINDOW_CONTROL_BACKGROUND_RESTORED_P;
 397   }
 398   caption_button_container_->SetButtonImages(
 399       ash::CAPTION_BUTTON_ICON_MINIMIZE,
 400       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_MINIMIZE,
 401       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_MINIMIZE,
 402       hover_background_id,
 403       pressed_background_id);
 404   caption_button_container_->SetButtonImages(
 405       ash::CAPTION_BUTTON_ICON_MAXIMIZE_RESTORE,
 406       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_SIZE,
 407       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_SIZE,
 408       hover_background_id,
 409       pressed_background_id);
 410   caption_button_container_->SetButtonImages(
 411       ash::CAPTION_BUTTON_ICON_CLOSE,
 412       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_CLOSE,
 413       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_CLOSE,
 414       hover_background_id,
 415       pressed_background_id);
 416   caption_button_container_->SetButtonImages(
 417       ash::CAPTION_BUTTON_ICON_LEFT_SNAPPED,
 418       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_LEFT_SNAPPED,
 419       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_LEFT_SNAPPED,
 420       hover_background_id,
 421       pressed_background_id);
 422   caption_button_container_->SetButtonImages(
 423       ash::CAPTION_BUTTON_ICON_RIGHT_SNAPPED,
 424       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_RIGHT_SNAPPED,
 425       IDR_ASH_BROWSER_WINDOW_CONTROL_ICON_RIGHT_SNAPPED,
 426       hover_background_id,
 427       pressed_background_id);
 428 }
 429
 430 gfx::Rect BrowserHeaderPainterAsh::GetPaintedBounds() const {
 431   return gfx::Rect(view_->width(), painted_height_);
 432 }
 433
 434 gfx::Rect BrowserHeaderPainterAsh::GetTitleBounds() const {
 435   return ash::HeaderPainterUtil::GetTitleBounds(window_icon_,
 436       caption_button_container_, BrowserFrame::GetTitleFontList());
 437 }