More flexibility in BubbleBorder arrow rendering.

ui/views/bubble/bubble_border.cc

 // Copyright (c) 2012 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 "ui/views/bubble/bubble_border.h"
 
 #include <algorithm>  // for std::max
 
 #include "base/logging.h"
 #include "grit/ui_resources.h"
@@ skipping 118 matching lines @@
   int corner_radius;
 };
 
 // static
 struct BubbleBorder::BorderImages*
     BubbleBorder::border_images_[SHADOW_COUNT] = { NULL };
 
 BubbleBorder::BubbleBorder(ArrowLocation arrow, Shadow shadow, SkColor color)
     : override_arrow_offset_(0),
       arrow_location_(arrow),
-      paint_arrow_(true),
+      arrow_paint_type_(PAINT_NORMAL),
       alignment_(ALIGN_ARROW_TO_MID_ANCHOR),
       background_color_(color) {
   DCHECK(shadow < SHADOW_COUNT);
   images_ = GetBorderImages(shadow);
 
   // Calculate horizontal and vertical insets for arrow by ensuring that
   // the widest arrow and corner images will have enough room to avoid overlap
   int offset_x =
       (std::max(images_->top_arrow.width(),
                 images_->bottom_arrow.width()) / 2) +
@@ skipping 25 matching lines @@
     border_size.set_height(std::max(border_size.height(), 2 * arrow_offset_));
 
   // Screen position depends on the arrow location.
   // The bubble should overlap the target by some amount since there is space
   // for shadow between arrow tip/bubble border and image bounds.
   int x = position_relative_to.x();
   int y = position_relative_to.y();
   int w = position_relative_to.width();
   int h = position_relative_to.height();
 
-  const int arrow_size = images_->arrow_interior_height + kBorderStrokeSize;
+  const int arrow_size = GetArrowSize();
   const int arrow_offset = GetArrowOffset(border_size);
 
   // Calculate bubble x coordinate.
   switch (arrow_location_) {
     case TOP_LEFT:
     case BOTTOM_LEFT:
       x += alignment_ == ALIGN_ARROW_TO_MID_ANCHOR ? w / 2 - arrow_offset :
            -(images_->left.width() - kBorderStrokeSize);
       break;
 
@@ skipping 117 matching lines @@
 }
 
 int BubbleBorder::GetBorderThickness() const {
   return images_->border_thickness;
 }
 
 int BubbleBorder::GetBorderCornerRadius() const {
   return images_->corner_radius;
 }
 
+int BubbleBorder::GetArrowSize() const {
+  if (arrow_paint_type_ == PAINT_NONE)
+    return 0;
+  return images_->arrow_interior_height + kBorderStrokeSize;
+}
+
 int BubbleBorder::GetArrowOffset(const gfx::Size& border_size) const {
   int arrow_offset = arrow_offset_;
   if (override_arrow_offset_) {
     arrow_offset = override_arrow_offset_;
   } else if (is_arrow_at_center(arrow_location_)) {
     if (is_arrow_on_horizontal(arrow_location_))
       arrow_offset = border_size.width() / 2;
     else
       arrow_offset = border_size.height() / 2;
   }
@@ skipping 74 matching lines @@
   if (!is_arrow_at_center(arrow_location_)) {
     if (is_arrow_on_horizontal(arrow_location_) &&
         !is_arrow_on_left(arrow_location_)) {
       arrow_offset = view.width() - arrow_offset - 1;
     } else if (!is_arrow_on_horizontal(arrow_location_) &&
                !is_arrow_on_top(arrow_location_)) {
       arrow_offset = view.height() - arrow_offset - 1;
     }
   }
 
-  const ArrowLocation arrow_location = paint_arrow_ ? arrow_location_ : NONE;
+  const ArrowLocation arrow_location =
+      arrow_paint_type_ == PAINT_NORMAL ? arrow_location_ : NONE;
 
   // Left edge.
   if (arrow_location == LEFT_TOP ||
       arrow_location == LEFT_CENTER ||
       arrow_location == LEFT_BOTTOM) {
     int start_y = top + tl_height;
     int before_arrow =
         arrow_offset - start_y - images_->left_arrow.height() / 2;
     int after_arrow = height - tl_height - bl_height -
         images_->left_arrow.height() - before_arrow;
@@ skipping 196 matching lines @@
   paint.setColor(border_->background_color());
   SkPath path;
   gfx::Rect bounds(view->GetContentsBounds());
   bounds.Inset(-border_->GetBorderThickness(), -border_->GetBorderThickness());
   SkScalar radius = SkIntToScalar(border_->GetBorderCornerRadius());
   path.addRoundRect(gfx::RectToSkRect(bounds), radius, radius);
   canvas->DrawPath(path, paint);
 }
 
 }  // namespace views