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 #ifndef UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_ 6 #define UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_ 7 8 #include "base/basictypes.h" 9 #include "base/compiler_specific.h" 10 #include "ui/views/background.h" 11 #include "ui/views/border.h" 12 13 namespace gfx { 14 class ImageSkia; 15 class Rect; 16 } 17 18 namespace views { 19 20 namespace internal { 21 struct BorderImages; 22 } 23 24 // Renders a border, with optional arrow, and a custom dropshadow. 25 // This can be used to produce floating "bubble" objects with rounded corners. 26 class VIEWS_EXPORT BubbleBorder : public Border { 27 public: 28 // Possible locations for the (optional) arrow. 29 // 0 bit specifies left or right. 30 // 1 bit specifies top or bottom. 31 // 2 bit specifies horizontal or vertical. 32 // 3 bit specifies whether the arrow at the center of its residing edge. 33 enum ArrowMask { 34 RIGHT = 0x01, 35 BOTTOM = 0x02, 36 VERTICAL = 0x04, 37 CENTER = 0x08, 38 }; 39 40 enum Arrow { 41 TOP_LEFT = 0, 42 TOP_RIGHT = RIGHT, 43 BOTTOM_LEFT = BOTTOM, 44 BOTTOM_RIGHT = BOTTOM | RIGHT, 45 LEFT_TOP = VERTICAL, 46 RIGHT_TOP = VERTICAL | RIGHT, 47 LEFT_BOTTOM = VERTICAL | BOTTOM, 48 RIGHT_BOTTOM = VERTICAL | BOTTOM | RIGHT, 49 TOP_CENTER = CENTER, 50 BOTTOM_CENTER = CENTER | BOTTOM, 51 LEFT_CENTER = CENTER | VERTICAL, 52 RIGHT_CENTER = CENTER | VERTICAL | RIGHT, 53 NONE = 16, // No arrow. Positioned under the supplied rect. 54 FLOAT = 17, // No arrow. Centered over the supplied rect. 55 }; 56 57 enum Shadow { 58 NO_SHADOW = 0, 59 NO_SHADOW_OPAQUE_BORDER, 60 BIG_SHADOW, 61 SMALL_SHADOW, 62 SHADOW_COUNT, 63 }; 64 65 // The position of the bubble in relation to the anchor. 66 enum BubbleAlignment { 67 // The tip of the arrow points to the middle of the anchor. 68 ALIGN_ARROW_TO_MID_ANCHOR, 69 // The edge nearest to the arrow is lined up with the edge of the anchor. 70 ALIGN_EDGE_TO_ANCHOR_EDGE, 71 }; 72 73 // The way the arrow should be painted. 74 enum ArrowPaintType { 75 // Fully render the arrow. 76 PAINT_NORMAL, 77 // Leave space for the arrow, but do not paint it. 78 PAINT_TRANSPARENT, 79 // Neither paint nor leave space for the arrow. 80 PAINT_NONE, 81 }; 82 83 BubbleBorder(Arrow arrow, Shadow shadow, SkColor color); 84 virtual ~BubbleBorder(); 85 86 // Returns the radius of the corner of the border. 87 // TODO(xiyuan): Get rid of this since it's part of BorderImages now? 88 static int GetCornerRadius() { 89 // We can't safely calculate a border radius by comparing the sizes of the 90 // side and corner images, because either may have been extended in various 91 // directions in order to do more subtle dropshadow fading or other effects. 92 // So we hardcode the most accurate value. 93 return 4; 94 } 95 96 static bool has_arrow(Arrow a) { return a < NONE; } 97 98 static bool is_arrow_on_left(Arrow a) { 99 return has_arrow(a) && (a == LEFT_CENTER || !(a & (RIGHT | CENTER))); 100 } 101 102 static bool is_arrow_on_top(Arrow a) { 103 return has_arrow(a) && (a == TOP_CENTER || !(a & (BOTTOM | CENTER))); 104 } 105 106 static bool is_arrow_on_horizontal(Arrow a) { 107 return a >= NONE ? false : !(a & VERTICAL); 108 } 109 110 static bool is_arrow_at_center(Arrow a) { 111 return has_arrow(a) && !!(a & CENTER); 112 } 113 114 static Arrow horizontal_mirror(Arrow a) { 115 return (a == TOP_CENTER || a == BOTTOM_CENTER || a >= NONE) ? 116 a : static_cast<Arrow>(a ^ RIGHT); 117 } 118 119 static Arrow vertical_mirror(Arrow a) { 120 return (a == LEFT_CENTER || a == RIGHT_CENTER || a >= NONE) ? 121 a : static_cast<Arrow>(a ^ BOTTOM); 122 } 123 124 // Get or set the arrow type. 125 void set_arrow(Arrow arrow) { arrow_ = arrow; } 126 Arrow arrow() const { return arrow_; } 127 128 // Get or set the bubble alignment. 129 void set_alignment(BubbleAlignment alignment) { alignment_ = alignment; } 130 BubbleAlignment alignment() const { return alignment_; } 131 132 // Get the shadow type. 133 Shadow shadow() const { return shadow_; } 134 135 // Get or set the background color for the bubble and arrow body. 136 void set_background_color(SkColor color) { background_color_ = color; } 137 SkColor background_color() const { return background_color_; } 138 139 // If true, the background color should be determined by the host's 140 // NativeTheme. 141 void set_use_theme_background_color(bool use_theme_background_color) { 142 use_theme_background_color_ = use_theme_background_color; 143 } 144 bool use_theme_background_color() { return use_theme_background_color_; } 145 146 // Sets a desired pixel distance between the arrow tip and the outside edge of 147 // the neighboring border image. For example: |----offset----| 148 // '(' represents shadow around the '{' edge: ((({ ^ }))) 149 // The arrow will still anchor to the same location but the bubble will shift 150 // location to place the arrow |offset| pixels from the perpendicular edge. 151 void set_arrow_offset(int offset) { arrow_offset_ = offset; } 152 153 // Sets the way the arrow is actually painted. Default is PAINT_NORMAL. 154 void set_paint_arrow(ArrowPaintType value) { arrow_paint_type_ = value; } 155 156 // Get the desired widget bounds (in screen coordinates) given the anchor rect 157 // and bubble content size; calculated from shadow and arrow image dimensions. 158 virtual gfx::Rect GetBounds(const gfx::Rect& anchor_rect, 159 const gfx::Size& contents_size) const; 160 161 // Get the border exterior thickness, including stroke and shadow, in pixels. 162 int GetBorderThickness() const; 163 164 // Returns the corner radius of the current image set. 165 int GetBorderCornerRadius() const; 166 167 // Gets the arrow offset to use. 168 int GetArrowOffset(const gfx::Size& border_size) const; 169 170 // Overridden from Border: 171 virtual void Paint(const View& view, gfx::Canvas* canvas) OVERRIDE; 172 virtual gfx::Insets GetInsets() const OVERRIDE; 173 virtual gfx::Size GetMinimumSize() const OVERRIDE; 174 175 private: 176 gfx::Size GetSizeForContentsSize(const gfx::Size& contents_size) const; 177 gfx::ImageSkia* GetArrowImage() const; 178 gfx::Rect GetArrowRect(const gfx::Rect& bounds) const; 179 void DrawArrow(gfx::Canvas* canvas, const gfx::Rect& arrow_bounds) const; 180 181 Arrow arrow_; 182 int arrow_offset_; 183 ArrowPaintType arrow_paint_type_; 184 BubbleAlignment alignment_; 185 Shadow shadow_; 186 internal::BorderImages* images_; 187 SkColor background_color_; 188 bool use_theme_background_color_; 189 190 DISALLOW_COPY_AND_ASSIGN(BubbleBorder); 191 }; 192 193 // A Background that clips itself to the specified BubbleBorder and uses 194 // the background color of the BubbleBorder. 195 class VIEWS_EXPORT BubbleBackground : public Background { 196 public: 197 explicit BubbleBackground(BubbleBorder* border) : border_(border) {} 198 199 // Overridden from Background: 200 virtual void Paint(gfx::Canvas* canvas, View* view) const OVERRIDE; 201 202 private: 203 BubbleBorder* border_; 204 205 DISALLOW_COPY_AND_ASSIGN(BubbleBackground); 206 }; 207 208 } // namespace views 209 210 #endif // UI_VIEWS_BUBBLE_BUBBLE_BORDER_H_ 211
