More flexibility in BubbleBorder arrow rendering.

ui/views/bubble/bubble_border.h

 // 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.
 
 #ifndef UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_
 #define UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "ui/views/background.h"
@@ skipping 47 matching lines @@
   };
 
   // The position of the bubble in relation to the anchor.
   enum BubbleAlignment {
     // The tip of the arrow points to the middle of the anchor.
     ALIGN_ARROW_TO_MID_ANCHOR,
     // The edge nearest to the arrow is lined up with the edge of the anchor.
     ALIGN_EDGE_TO_ANCHOR_EDGE
   };
 
+  // The way the arrow should be painted.

[msw, 2013/02/21 07:29:29]

nit: describe values meanings like your awesome cl description text.

[dewittj, 2013/02/21 19:13:57]

Done.

+  enum ArrowPaintType {
+    PAINT_NORMAL,
+    PAINT_TRANSPARENT,
+    PAINT_NONE,
+  };
+
   BubbleBorder(ArrowLocation arrow, Shadow shadow, SkColor color);
 
   // Returns the radius of the corner of the border.
   // TODO(xiyuan): Get rid of this since it's part of BorderImages now?
   static int GetCornerRadius() {
     // We can't safely calculate a border radius by comparing the sizes of the
     // side and corner images, because either may have been extended in various
     // directions in order to do more subtle dropshadow fading or other effects.
     // So we hardcode the most accurate value.
     return 4;
@@ skipping 45 matching lines @@
   SkColor background_color() const { return background_color_; }
 
   void set_client_bounds(const gfx::Rect& bounds) { client_bounds_ = bounds; }
   const gfx::Rect& client_bounds() const { return client_bounds_; }
 
   // Sets a fixed offset for the arrow from the beginning of corresponding edge.
   // The arrow will still point to the same location but the bubble will shift
   // location to make that happen.
   void set_arrow_offset(int offset) { override_arrow_offset_ = offset; }
 
-  // Sets whether the arrow is actually painted. If false, an arrow may still be
-  // used for the geometry computations, but it is not shown. Default is true.
-  void set_paint_arrow(bool value) { paint_arrow_ = value; }
+  // Sets the way the arrow is actually painted.  Default is PAINT_NORMAL.
+  void set_paint_arrow(ArrowPaintType value) { arrow_paint_type_ = value; }
 
   // For borders with an arrow, gives the desired bounds (in screen coordinates)
   // given the rect to point to and the size of the contained contents.  This
   // depends on the arrow location, so if you change that, you should call this
   // again to find out the new coordinates.
   virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
                               const gfx::Size& contents_size) const;
 
   // Returns the corner radius of the current image set.
   int GetBorderCornerRadius() const;
@@ skipping 14 matching lines @@
   // GetInsets(arrow_location()), but may be called by specialized BubbleBorder
   // implementations.
   virtual gfx::Insets GetInsetsForArrowLocation(ArrowLocation arrow_loc) const;
 
  private:
   struct BorderImages;
 
   // Loads images if necessary.
   static BorderImages* GetBorderImages(Shadow shadow);
 
+  int GetArrowSize() const;
+
   // Overridden from Border:
   virtual void Paint(const View& view, gfx::Canvas* canvas) OVERRIDE;
 
   void DrawEdgeWithArrow(gfx::Canvas* canvas,
                          bool is_horizontal,
                          const gfx::ImageSkia& edge,
                          const gfx::ImageSkia& arrow,
                          int start_x,
                          int start_y,
                          int before_arrow,
                          int after_arrow,
                          int offset) const;
 
   void DrawArrowInterior(gfx::Canvas* canvas, float tip_x, float tip_y) const;
 
   // Border graphics.
   struct BorderImages* images_;
 
   // Image bundles.
   static struct BorderImages* border_images_[SHADOW_COUNT];
 
   // Minimal offset of the arrow from the closet edge of bounding rect.
   int arrow_offset_;
 
   // If specified, overrides the pre-calculated |arrow_offset_| of the arrow.
   int override_arrow_offset_;
 
   ArrowLocation arrow_location_;
-  // See description above setter.
-  bool paint_arrow_;
+  ArrowPaintType arrow_paint_type_;
   BubbleAlignment alignment_;
   SkColor background_color_;
 
   // The client/content bounds; must be clipped from the background on Windows.
   // TODO(msw): Clean this up when Windows native controls are no longer needed.
   gfx::Rect client_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleBorder);
 };
 
 // A Background that clips itself to the specified BubbleBorder and uses
 // the background color of the BubbleBorder.
 class VIEWS_EXPORT BubbleBackground : public Background {
  public:
   explicit BubbleBackground(BubbleBorder* border) : border_(border) {}
 
   // Overridden from Background:
   virtual void Paint(gfx::Canvas* canvas, View* view) const OVERRIDE;
 
  private:
   BubbleBorder* border_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleBackground);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_