ui/views/bubble/bubble_border.cc

   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 "ui/views/bubble/bubble_border.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "grit/ui_resources.h"
  12 #include "ui/base/resource/resource_bundle.h"
  13 #include "ui/gfx/canvas.h"
  14 #include "ui/gfx/image/image_skia.h"
  15 #include "ui/gfx/rect.h"
  16 #include "ui/gfx/skia_util.h"
  17 #include "ui/views/painter.h"
  18 #include "ui/views/view.h"
  19
  20 namespace views {
  21
  22 namespace internal {
  23
  24 // A helper that combines each border image-set painter with arrows and metrics.
  25 struct BorderImages {
  26   BorderImages(const int border_image_ids[],
  27                const int arrow_image_ids[],
  28                int border_interior_thickness,
  29                int arrow_interior_thickness,
  30                int corner_radius);
  31
  32   scoped_ptr<Painter> border_painter;
  33   gfx::ImageSkia left_arrow;
  34   gfx::ImageSkia top_arrow;
  35   gfx::ImageSkia right_arrow;
  36   gfx::ImageSkia bottom_arrow;
  37
  38   // The thickness of border and arrow images and their interior areas.
  39   // Thickness is the width of left/right and the height of top/bottom images.
  40   // The interior is measured without including stroke or shadow pixels.
  41   int border_thickness;
  42   int border_interior_thickness;
  43   int arrow_thickness;
  44   int arrow_interior_thickness;
  45   // The corner radius of the bubble's rounded-rect interior area.
  46   int corner_radius;
  47 };
  48
  49 BorderImages::BorderImages(const int border_image_ids[],
  50                            const int arrow_image_ids[],
  51                            int border_interior_thickness,
  52                            int arrow_interior_thickness,
  53                            int corner_radius)
  54     : border_painter(Painter::CreateImageGridPainter(border_image_ids)),
  55       border_thickness(0),
  56       border_interior_thickness(border_interior_thickness),
  57       arrow_thickness(0),
  58       arrow_interior_thickness(arrow_interior_thickness),
  59       corner_radius(corner_radius) {
  60   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
  61   border_thickness = rb.GetImageSkiaNamed(border_image_ids[0])->width();
  62   if (arrow_image_ids[0] != 0) {
  63     left_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[0]);
  64     top_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[1]);
  65     right_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[2]);
  66     bottom_arrow = *rb.GetImageSkiaNamed(arrow_image_ids[3]);
  67     arrow_thickness = top_arrow.height();
  68   }
  69 }
  70
  71 }  // namespace internal
  72
  73 namespace {
  74
  75 // The border and arrow stroke size used in image assets, in pixels.
  76 const int kStroke = 1;
  77
  78 // Bubble border and arrow image resource ids. They don't use the IMAGE_GRID
  79 // macro because there is no center image.
  80 const int kNoShadowImages[] = {
  81     IDR_BUBBLE_TL, IDR_BUBBLE_T, IDR_BUBBLE_TR,
  82     IDR_BUBBLE_L,  0,            IDR_BUBBLE_R,
  83     IDR_BUBBLE_BL, IDR_BUBBLE_B, IDR_BUBBLE_BR };
  84 const int kNoShadowArrows[] = {
  85     IDR_BUBBLE_L_ARROW, IDR_BUBBLE_T_ARROW,
  86     IDR_BUBBLE_R_ARROW, IDR_BUBBLE_B_ARROW, };
  87
  88 const int kBigShadowImages[] = {
  89     IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP_LEFT,
  90     IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP,
  91     IDR_WINDOW_BUBBLE_SHADOW_BIG_TOP_RIGHT,
  92     IDR_WINDOW_BUBBLE_SHADOW_BIG_LEFT,
  93     0,
  94     IDR_WINDOW_BUBBLE_SHADOW_BIG_RIGHT,
  95     IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM_LEFT,
  96     IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM,
  97     IDR_WINDOW_BUBBLE_SHADOW_BIG_BOTTOM_RIGHT };
  98 const int kBigShadowArrows[] = {
  99     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_LEFT,
 100     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_TOP,
 101     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_RIGHT,
 102     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_BIG_BOTTOM };
 103
 104 const int kSmallShadowImages[] = {
 105     IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP_LEFT,
 106     IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP,
 107     IDR_WINDOW_BUBBLE_SHADOW_SMALL_TOP_RIGHT,
 108     IDR_WINDOW_BUBBLE_SHADOW_SMALL_LEFT,
 109     0,
 110     IDR_WINDOW_BUBBLE_SHADOW_SMALL_RIGHT,
 111     IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM_LEFT,
 112     IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM,
 113     IDR_WINDOW_BUBBLE_SHADOW_SMALL_BOTTOM_RIGHT };
 114 const int kSmallShadowArrows[] = {
 115     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_LEFT,
 116     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_TOP,
 117     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_RIGHT,
 118     IDR_WINDOW_BUBBLE_SHADOW_SPIKE_SMALL_BOTTOM };
 119
 120 using internal::BorderImages;
 121
 122 // Returns the cached BorderImages for the given |shadow| type.
 123 BorderImages* GetBorderImages(BubbleBorder::Shadow shadow) {
 124   // Keep a cache of bubble border image-set painters, arrows, and metrics.
 125   static BorderImages* kBorderImages[BubbleBorder::SHADOW_COUNT] = { NULL };
 126
 127   CHECK_LT(shadow, BubbleBorder::SHADOW_COUNT);
 128   struct BorderImages*& set = kBorderImages[shadow];
 129   if (set)
 130     return set;
 131
 132   switch (shadow) {
 133     case BubbleBorder::NO_SHADOW:
 134     case BubbleBorder::NO_SHADOW_OPAQUE_BORDER:
 135       set = new BorderImages(kNoShadowImages, kNoShadowArrows, 6, 7, 4);
 136       break;
 137     case BubbleBorder::BIG_SHADOW:
 138       set = new BorderImages(kBigShadowImages, kBigShadowArrows, 23, 9, 2);
 139       break;
 140     case BubbleBorder::SMALL_SHADOW:
 141       set = new BorderImages(kSmallShadowImages, kSmallShadowArrows, 5, 6, 2);
 142       break;
 143     case BubbleBorder::SHADOW_COUNT:
 144       NOTREACHED();
 145       break;
 146   }
 147
 148   return set;
 149 }
 150
 151 }  // namespace
 152
 153 BubbleBorder::BubbleBorder(Arrow arrow, Shadow shadow, SkColor color)
 154     : arrow_(arrow),
 155       arrow_offset_(0),
 156       arrow_paint_type_(PAINT_NORMAL),
 157       alignment_(ALIGN_ARROW_TO_MID_ANCHOR),
 158       shadow_(shadow),
 159       background_color_(color),
 160       use_theme_background_color_(false) {
 161   DCHECK(shadow < SHADOW_COUNT);
 162   images_ = GetBorderImages(shadow);
 163 }
 164
 165 BubbleBorder::~BubbleBorder() {}
 166
 167 gfx::Rect BubbleBorder::GetBounds(const gfx::Rect& anchor_rect,
 168                                   const gfx::Size& contents_size) const {
 169   int x = anchor_rect.x();
 170   int y = anchor_rect.y();
 171   int w = anchor_rect.width();
 172   int h = anchor_rect.height();
 173   const gfx::Size size(GetSizeForContentsSize(contents_size));
 174   const int arrow_offset = GetArrowOffset(size);
 175   const int arrow_size =
 176       images_->arrow_interior_thickness + kStroke - images_->arrow_thickness;
 177   const bool mid_anchor = alignment_ == ALIGN_ARROW_TO_MID_ANCHOR;
 178
 179   // Calculate the bubble coordinates based on the border and arrow settings.
 180   if (is_arrow_on_horizontal(arrow_)) {
 181     if (is_arrow_on_left(arrow_)) {
 182       x += mid_anchor ? w / 2 - arrow_offset : kStroke - GetBorderThickness();
 183     } else if (is_arrow_at_center(arrow_)) {
 184       x += w / 2 - arrow_offset;
 185     } else {
 186       x += mid_anchor ? w / 2 + arrow_offset - size.width() :
 187                         w - size.width() + GetBorderThickness() - kStroke;
 188     }
 189     y += is_arrow_on_top(arrow_) ? h + arrow_size : -arrow_size - size.height();
 190   } else if (has_arrow(arrow_)) {
 191     x += is_arrow_on_left(arrow_) ? w + arrow_size : -arrow_size - size.width();
 192     if (is_arrow_on_top(arrow_)) {
 193       y += mid_anchor ? h / 2 - arrow_offset : kStroke - GetBorderThickness();
 194     } else if (is_arrow_at_center(arrow_)) {
 195       y += h / 2 - arrow_offset;
 196     } else {
 197       y += mid_anchor ? h / 2 + arrow_offset - size.height() :
 198                         h - size.height() + GetBorderThickness() - kStroke;
 199     }
 200   } else {
 201     x += (w - size.width()) / 2;
 202     y += (arrow_ == NONE) ? h : (h - size.height()) / 2;
 203   }
 204
 205   return gfx::Rect(x, y, size.width(), size.height());
 206 }
 207
 208 int BubbleBorder::GetBorderThickness() const {
 209   return images_->border_thickness - images_->border_interior_thickness;
 210 }
 211
 212 int BubbleBorder::GetBorderCornerRadius() const {
 213   return images_->corner_radius;
 214 }
 215
 216 int BubbleBorder::GetArrowOffset(const gfx::Size& border_size) const {
 217   const int edge_length = is_arrow_on_horizontal(arrow_) ?
 218       border_size.width() : border_size.height();
 219   if (is_arrow_at_center(arrow_) && arrow_offset_ == 0)
 220     return edge_length / 2;
 221
 222   // Calculate the minimum offset to not overlap arrow and corner images.
 223   const int min = images_->border_thickness + (images_->top_arrow.width() / 2);
 224   // Ensure the returned value will not cause image overlap, if possible.
 225   return std::max(min, std::min(arrow_offset_, edge_length - min));
 226 }
 227
 228 void BubbleBorder::Paint(const views::View& view, gfx::Canvas* canvas) {
 229   gfx::Rect bounds(view.GetContentsBounds());
 230   bounds.Inset(-GetBorderThickness(), -GetBorderThickness());
 231   const gfx::Rect arrow_bounds = GetArrowRect(view.GetLocalBounds());
 232   if (arrow_bounds.IsEmpty()) {
 233     Painter::PaintPainterAt(canvas, images_->border_painter.get(), bounds);
 234     return;
 235   }
 236
 237   // Clip the arrow bounds out to avoid painting the overlapping edge area.
 238   canvas->Save();
 239   SkRect arrow_rect(gfx::RectToSkRect(arrow_bounds));
 240   canvas->sk_canvas()->clipRect(arrow_rect, SkRegion::kDifference_Op);
 241   Painter::PaintPainterAt(canvas, images_->border_painter.get(), bounds);
 242   canvas->Restore();
 243
 244   DrawArrow(canvas, arrow_bounds);
 245 }
 246
 247 gfx::Insets BubbleBorder::GetInsets() const {
 248   // The insets contain the stroke and shadow pixels outside the bubble fill.
 249   const int inset = GetBorderThickness();
 250   if ((arrow_paint_type_ == PAINT_NONE) || !has_arrow(arrow_))
 251     return gfx::Insets(inset, inset, inset, inset);
 252
 253   int first_inset = inset;
 254   int second_inset = std::max(inset, images_->arrow_thickness);
 255   if (is_arrow_on_horizontal(arrow_) ?
 256       is_arrow_on_top(arrow_) : is_arrow_on_left(arrow_))
 257     std::swap(first_inset, second_inset);
 258   return is_arrow_on_horizontal(arrow_) ?
 259       gfx::Insets(first_inset, inset, second_inset, inset) :
 260       gfx::Insets(inset, first_inset, inset, second_inset);
 261 }
 262
 263 gfx::Size BubbleBorder::GetMinimumSize() const {
 264   return GetSizeForContentsSize(gfx::Size());
 265 }
 266
 267 gfx::Size BubbleBorder::GetSizeForContentsSize(
 268     const gfx::Size& contents_size) const {
 269   // Enlarge the contents size by the thickness of the border images.
 270   gfx::Size size(contents_size);
 271   const gfx::Insets insets = GetInsets();
 272   size.Enlarge(insets.width(), insets.height());
 273
 274   // Ensure the bubble is large enough to not overlap border and arrow images.
 275   const int min = 2 * images_->border_thickness;
 276   const int min_with_arrow_width = min + images_->top_arrow.width();
 277   const int min_with_arrow_thickness = images_->border_thickness +
 278       std::max(images_->arrow_thickness + images_->border_interior_thickness,
 279                images_->border_thickness);
 280   // Only take arrow image sizes into account when the bubble tip is shown.
 281   if (arrow_paint_type_ == PAINT_TRANSPARENT || !has_arrow(arrow_))
 282     size.SetToMax(gfx::Size(min, min));
 283   else if (is_arrow_on_horizontal(arrow_))
 284     size.SetToMax(gfx::Size(min_with_arrow_width, min_with_arrow_thickness));
 285   else
 286     size.SetToMax(gfx::Size(min_with_arrow_thickness, min_with_arrow_width));
 287   return size;
 288 }
 289
 290 gfx::ImageSkia* BubbleBorder::GetArrowImage() const {
 291   if (!has_arrow(arrow_))
 292     return NULL;
 293   if (is_arrow_on_horizontal(arrow_)) {
 294     return is_arrow_on_top(arrow_) ?
 295         &images_->top_arrow : &images_->bottom_arrow;
 296   }
 297   return is_arrow_on_left(arrow_) ?
 298       &images_->left_arrow : &images_->right_arrow;
 299 }
 300
 301 gfx::Rect BubbleBorder::GetArrowRect(const gfx::Rect& bounds) const {
 302   if (!has_arrow(arrow_) || arrow_paint_type_ != PAINT_NORMAL)
 303     return gfx::Rect();
 304
 305   gfx::Point origin;
 306   int offset = GetArrowOffset(bounds.size());
 307   const int half_length = images_->top_arrow.width() / 2;
 308   const gfx::Insets insets = GetInsets();
 309
 310   if (is_arrow_on_horizontal(arrow_)) {
 311     origin.set_x(is_arrow_on_left(arrow_) || is_arrow_at_center(arrow_) ?
 312         offset : bounds.width() - offset);
 313     origin.Offset(-half_length, 0);
 314     if (is_arrow_on_top(arrow_))
 315       origin.set_y(insets.top() - images_->arrow_thickness);
 316     else
 317       origin.set_y(bounds.height() - insets.bottom());
 318   } else {
 319     origin.set_y(is_arrow_on_top(arrow_)  || is_arrow_at_center(arrow_) ?
 320         offset : bounds.height() - offset);
 321     origin.Offset(0, -half_length);
 322     if (is_arrow_on_left(arrow_))
 323       origin.set_x(insets.left() - images_->arrow_thickness);
 324     else
 325       origin.set_x(bounds.width() - insets.right());
 326   }
 327   return gfx::Rect(origin, GetArrowImage()->size());
 328 }
 329
 330 void BubbleBorder::DrawArrow(gfx::Canvas* canvas,
 331                              const gfx::Rect& arrow_bounds) const {
 332   canvas->DrawImageInt(*GetArrowImage(), arrow_bounds.x(), arrow_bounds.y());
 333   const bool horizontal = is_arrow_on_horizontal(arrow_);
 334   const int thickness = images_->arrow_interior_thickness;
 335   float tip_x = horizontal ? arrow_bounds.CenterPoint().x() :
 336       is_arrow_on_left(arrow_) ? arrow_bounds.right() - thickness :
 337                                  arrow_bounds.x() + thickness;
 338   float tip_y = !horizontal ? arrow_bounds.CenterPoint().y() + 0.5f :
 339       is_arrow_on_top(arrow_) ? arrow_bounds.bottom() - thickness :
 340                                 arrow_bounds.y() + thickness;
 341   const bool positive_offset = horizontal ?
 342       is_arrow_on_top(arrow_) : is_arrow_on_left(arrow_);
 343   const int offset_to_next_vertex = positive_offset ?
 344       images_->arrow_interior_thickness : -images_->arrow_interior_thickness;
 345
 346   SkPath path;
 347   path.incReserve(4);
 348   path.moveTo(SkDoubleToScalar(tip_x), SkDoubleToScalar(tip_y));
 349   path.lineTo(SkDoubleToScalar(tip_x + offset_to_next_vertex),
 350               SkDoubleToScalar(tip_y + offset_to_next_vertex));
 351   const int multiplier = horizontal ? 1 : -1;
 352   path.lineTo(SkDoubleToScalar(tip_x - multiplier * offset_to_next_vertex),
 353               SkDoubleToScalar(tip_y + multiplier * offset_to_next_vertex));
 354   path.close();
 355
 356   SkPaint paint;
 357   paint.setStyle(SkPaint::kFill_Style);
 358   paint.setColor(background_color_);
 359
 360   canvas->DrawPath(path, paint);
 361 }
 362
 363 void BubbleBackground::Paint(gfx::Canvas* canvas, views::View* view) const {
 364   if (border_->shadow() == BubbleBorder::NO_SHADOW_OPAQUE_BORDER)
 365     canvas->DrawColor(border_->background_color());
 366
 367   // Fill the contents with a round-rect region to match the border images.
 368   SkPaint paint;
 369   paint.setAntiAlias(true);
 370   paint.setStyle(SkPaint::kFill_Style);
 371   paint.setColor(border_->background_color());
 372   SkPath path;
 373   gfx::Rect bounds(view->GetLocalBounds());
 374   bounds.Inset(border_->GetInsets());
 375
 376   SkScalar radius = SkIntToScalar(border_->GetBorderCornerRadius());
 377   path.addRoundRect(gfx::RectToSkRect(bounds), radius, radius);
 378   canvas->DrawPath(path, paint);
 379 }
 380
 381 }  // namespace views