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