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 382
