Add a drop shadow to the fullscreen exit bubble on windows.

views/bubble/bubble_border.h

 // Copyright (c) 2011 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 VIEWS_BUBBLE_BUBBLE_BORDER_H_
 #define VIEWS_BUBBLE_BUBBLE_BORDER_H_
 #pragma once
 
 #include "views/background.h"
 #include "views/border.h"
 
 class SkBitmap;
 
 namespace views {
 
+struct BorderImages {

[sky, 2011/11/15 05:06:37]

Forward declare this as a struct in BubbleBorder. Also, add a constructor to
NULL everything out.

[koz (OOO until 15th September), 2011/11/15 06:35:43]

I'm not sure I've understood you here - I've added the constructor and moved the
declaration of this struct into BubbleBorder. Is that right?

[sky, 2011/11/15 16:36:33]

Close. Since you don't actually need the implementation in the header I'm saying
forward declare it in the header (private section), then put the implementation
in the .cc.

[koz (OOO until 15th September), 2011/11/15 22:45:39]

Thanks for the clarification. Done.

+  SkBitmap* left;
+  SkBitmap* top_left;
+  SkBitmap* top;
+  SkBitmap* top_right;
+  SkBitmap* right;
+  SkBitmap* bottom_right;
+  SkBitmap* bottom;
+  SkBitmap* bottom_left;
+  SkBitmap* left_arrow;
+  SkBitmap* top_arrow;
+  SkBitmap* right_arrow;
+  SkBitmap* bottom_arrow;
+};
+

[sky, 2011/11/15 05:06:37]

nit: remove one of these lines.

[koz (OOO until 15th September), 2011/11/15 06:35:43]

Done.

+
 // Renders a border, with optional arrow, and a custom dropshadow.
 // This can be used to produce floating "bubble" objects with rounded corners.
 class VIEWS_EXPORT BubbleBorder : public views::Border {
  public:
   // Possible locations for the (optional) arrow.
   // 0 bit specifies left or right.
   // 1 bit specifies top or bottom.
   // 2 bit specifies horizontal or vertical.
   enum ArrowLocation {
     TOP_LEFT     = 0,
     TOP_RIGHT    = 1,
     BOTTOM_LEFT  = 2,
     BOTTOM_RIGHT = 3,
     LEFT_TOP     = 4,
     RIGHT_TOP    = 5,
     LEFT_BOTTOM  = 6,
     RIGHT_BOTTOM = 7,
     NONE  = 8,  // No arrow. Positioned under the supplied rect.
     FLOAT = 9   // No arrow. Centered over the supplied rect.
   };
 
+  enum Shadow {
+    SHADOW    = 0,
+    NO_SHADOW = 1
+  };
+
   // 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
   };
 
-  explicit BubbleBorder(ArrowLocation arrow_location)
+  BubbleBorder(ArrowLocation arrow_location, Shadow shadow)
       : override_arrow_offset_(0),
         arrow_location_(arrow_location),
         alignment_(ALIGN_ARROW_TO_MID_ANCHOR),
         background_color_(SK_ColorWHITE) {
-    InitClass();
+    InitClass(shadow);
   }
 
   // Returns the radius of the corner of the border.
   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 50 matching lines @@
   // The arrow will still point to the same location but the bubble will shift
   // location to make that happen. Returns actuall arrow offset, in case of
   // overflow it differ from desired.
   int SetArrowOffset(int offset, const gfx::Size& contents_size);
 
   // Overridden from views::Border:
   virtual void GetInsets(gfx::Insets* insets) const;
 
  private:
   // Loads images if necessary.
-  static void InitClass();
+  void InitClass(Shadow shadow);
 
   virtual ~BubbleBorder();
 
   // Overridden from views::Border:
   virtual void Paint(const views::View& view, gfx::Canvas* canvas) const;
 
   void DrawEdgeWithArrow(gfx::Canvas* canvas,
                          bool is_horizontal,
                          SkBitmap* edge,
                          SkBitmap* arrow,
                          int start_x,
                          int start_y,
                          int before_arrow,
                          int after_arrow,
                          int offset) const;
 
   void DrawArrowInterior(gfx::Canvas* canvas,
                          bool is_horizontal,
                          int tip_x,
                          int tip_y,
                          int shift_x,
                          int shift_y) const;
 
   // Border graphics.
-  static SkBitmap* left_;
-  static SkBitmap* top_left_;
-  static SkBitmap* top_;
-  static SkBitmap* top_right_;
-  static SkBitmap* right_;
-  static SkBitmap* bottom_right_;
-  static SkBitmap* bottom_;
-  static SkBitmap* bottom_left_;
-  static SkBitmap* left_arrow_;
-  static SkBitmap* top_arrow_;
-  static SkBitmap* right_arrow_;
-  static SkBitmap* bottom_arrow_;
+  SkBitmap* left_;

[sky, 2011/11/15 05:06:37]

It's weird to have this and the struct. How about adding a field of type
BorderImages* that is one of normal_images_ or shadow_images_. Or cache Shadow
and look up the BorderImages when needed.

[koz (OOO until 15th September), 2011/11/15 06:35:43]

Done.

+  SkBitmap* top_left_;
+  SkBitmap* top_;
+  SkBitmap* top_right_;
+  SkBitmap* right_;
+  SkBitmap* bottom_right_;
+  SkBitmap* bottom_;
+  SkBitmap* bottom_left_;
+  SkBitmap* left_arrow_;
+  SkBitmap* top_arrow_;
+  SkBitmap* right_arrow_;
+  SkBitmap* bottom_arrow_;
+
+  // Image bundles.
+  static struct BorderImages* normal_images_;
+  static struct BorderImages* shadow_images_;
 
   // Minimal offset of the arrow from the closet edge of bounding rect.
-  static int arrow_offset_;
+  int arrow_offset_;
 
   // If specified, overrides the pre-calculated |arrow_offset_| of the arrow.
   int override_arrow_offset_;
 
   ArrowLocation arrow_location_;
   BubbleAlignment alignment_;
   SkColor background_color_;
 
   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 views::Background {
  public:
   explicit BubbleBackground(BubbleBorder* border) : border_(border) {}
 
   // Background overrides.
   virtual void Paint(gfx::Canvas* canvas, views::View* view) const;
 
  private:
   BubbleBorder* border_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleBackground);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_BUBBLE_BUBBLE_BORDER_H_