Implement message center on Windows

ui/views/bubble/tray_bubble_view.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/tray_bubble_view.h"
 
 #include <algorithm>
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 25 matching lines @@
 namespace views {
 
 namespace internal {
 
 // Custom border for TrayBubbleView. Contains special logic for GetBounds()
 // to stack bubbles with no arrows correctly. Also calculates the arrow offset.
 class TrayBubbleBorder : public views::BubbleBorder {
  public:
   TrayBubbleBorder(views::View* owner,
                    views::View* anchor,
+                   gfx::Point anchor_point,
                    TrayBubbleView::InitParams params)
       : views::BubbleBorder(params.arrow_location, params.shadow),
         owner_(owner),
         anchor_(anchor),
+        anchor_point_(anchor_point.x(), anchor_point.y()),
         tray_arrow_offset_(params.arrow_offset) {
-    set_alignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+    set_alignment(params.arrow_alignment);
     set_background_color(params.arrow_color);
   }
 
   virtual ~TrayBubbleBorder() {}
 
   // Overridden from views::BubbleBorder.
   // Override views::BubbleBorder to set the bubble on top of the anchor when
   // it has no arrow.
   virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
                               const gfx::Size& contents_size) const OVERRIDE {
-    if (arrow_location() != NONE) {
+    if (has_arrow(arrow_location())) {
       return views::BubbleBorder::GetBounds(position_relative_to,
                                             contents_size);
     }
 
     gfx::Size border_size(contents_size);
     gfx::Insets insets = GetInsets();
     border_size.Enlarge(insets.width(), insets.height());
 
     const int x = position_relative_to.x() +
         position_relative_to.width() / 2 - border_size.width() / 2;
     // Position the bubble on top of the anchor.
     const int y = position_relative_to.y() - border_size.height()
         + insets.height() - kBubbleSpacing;
     return gfx::Rect(x, y, border_size.width(), border_size.height());
   }
 
+  // Anchor point is in screen coordinates.
   void UpdateArrowOffset() {
+    if (!has_arrow(arrow_location())) {
+      return;
+    }
+
     int arrow_offset = 0;
-    if (arrow_location() == views::BubbleBorder::BOTTOM_RIGHT ||
-        arrow_location() == views::BubbleBorder::BOTTOM_LEFT) {
-      // Note: tray_arrow_offset_ is relative to the anchor widget.
-      if (tray_arrow_offset_ ==
-          TrayBubbleView::InitParams::kArrowDefaultOffset) {
-        arrow_offset = kArrowMinOffset;
-      } else {
-        const int width = owner_->GetWidget()->GetContentsView()->width();
-        gfx::Point pt(tray_arrow_offset_, 0);
-        views::View::ConvertPointToScreen(
-            anchor_->GetWidget()->GetRootView(), &pt);
-        views::View::ConvertPointFromScreen(
-            owner_->GetWidget()->GetRootView(), &pt);
-        arrow_offset = pt.x();
-        if (arrow_location() == views::BubbleBorder::BOTTOM_RIGHT)
-          arrow_offset = width - arrow_offset;
-        arrow_offset = std::max(arrow_offset, kArrowMinOffset);
-      }
+    gfx::Point pt(0, 0);
+    if (tray_arrow_offset_ == TrayBubbleView::InitParams::kArrowDefaultOffset) {
+      set_arrow_offset(kArrowMinOffset);
+      return;
+    }
+    // Note: tray_arrow_offset_ is relative to the anchor widget.
+    if (is_arrow_on_horizontal(arrow_location()))
+        pt.set_x(tray_arrow_offset_);
+    else
+        pt.set_y(tray_arrow_offset_);
+
+    if (anchor_) {
+      views::View::ConvertPointToScreen(
+          anchor_->GetWidget()->GetRootView(), &pt);
     } else {
-      if (tray_arrow_offset_ ==
-          TrayBubbleView::InitParams::kArrowDefaultOffset) {
-        arrow_offset = kArrowMinOffset;
-      } else {
-        gfx::Point pt(0, tray_arrow_offset_);
-        views::View::ConvertPointToScreen(
-            anchor_->GetWidget()->GetRootView(), &pt);
-        views::View::ConvertPointFromScreen(
-            owner_->GetWidget()->GetRootView(), &pt);
-        arrow_offset = pt.y();
-        arrow_offset = std::max(arrow_offset, kArrowMinOffset);
-      }
+      pt.Offset(anchor_point_.x(), anchor_point_.y());
     }
+
+    views::View::ConvertPointFromScreen(
+        owner_->GetWidget()->GetRootView(), &pt);
+    const int width = owner_->GetWidget()->GetContentsView()->width();
+
+    if (is_arrow_on_horizontal(arrow_location())) {
+      arrow_offset = pt.x();
+      if (!is_arrow_on_left(arrow_location()))
+        arrow_offset = width - arrow_offset;
+    } else {
+      arrow_offset = pt.y();
+    }
+
+    arrow_offset = std::max(arrow_offset, kArrowMinOffset);
     set_arrow_offset(arrow_offset);
   }
 
  private:
   views::View* owner_;
   views::View* anchor_;
+  gfx::Point anchor_point_;
   const int tray_arrow_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayBubbleBorder);
 };
 
 // This mask layer clips the bubble's content so that it does not overwrite the
 // rounded bubble corners.
 // TODO(miket): This does not work on Windows. Implement layer masking or
 // alternate solutions if the TrayBubbleView is needed there in the future.
 class TrayBubbleContentMask : public ui::LayerDelegate {
@@ skipping 11 matching lines @@
  private:
   ui::Layer layer_;
   SkScalar corner_radius_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayBubbleContentMask);
 };
 
 TrayBubbleContentMask::TrayBubbleContentMask(int corner_radius)
     : layer_(ui::LAYER_TEXTURED),
       corner_radius_(corner_radius) {
+#ifdef USE_AURA
   layer_.set_delegate(this);
+#endif
 }
 
 TrayBubbleContentMask::~TrayBubbleContentMask() {
+#ifdef USE_AURA
   layer_.set_delegate(NULL);
+#endif
 }
 
 void TrayBubbleContentMask::OnPaintLayer(gfx::Canvas* canvas) {
   SkPath path;
   path.addRoundRect(gfx::RectToSkRect(gfx::Rect(layer()->bounds().size())),
                     corner_radius_, corner_radius_);
   SkPaint paint;
   paint.setAlpha(255);
   paint.setStyle(SkPaint::kFill_Style);
   canvas->DrawPath(path, paint);
@@ skipping 61 matching lines @@
     : anchor_type(anchor_type),
       anchor_alignment(anchor_alignment),
       min_width(min_width),
       max_width(max_width),
       max_height(0),
       can_activate(false),
       close_on_deactivate(true),
       arrow_color(SK_ColorBLACK),
       arrow_location(views::BubbleBorder::NONE),
       arrow_offset(kArrowDefaultOffset),
-      shadow(views::BubbleBorder::BIG_SHADOW) {
+      shadow(views::BubbleBorder::BIG_SHADOW),
+      arrow_alignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE) {
 }
 
 // static
 TrayBubbleView* TrayBubbleView::Create(gfx::NativeView parent_window,
                                        views::View* anchor,
                                        Delegate* delegate,
                                        InitParams* init_params) {
   // Set arrow_location here so that it can be passed correctly to the
   // BubbleView constructor.
   if (init_params->anchor_type == ANCHOR_TYPE_TRAY) {
@@ skipping 19 matching lines @@
     : views::BubbleDelegateView(anchor, init_params.arrow_location),
       params_(init_params),
       delegate_(delegate),
       preferred_width_(init_params.min_width),
       bubble_border_(NULL),
       is_gesture_dragging_(false) {
   set_parent_window(parent_window);
   set_notify_enter_exit_on_child(true);
   set_close_on_deactivate(init_params.close_on_deactivate);
   set_margins(gfx::Insets());
+  bubble_border_ = new TrayBubbleBorder(
+      this,
+      anchor_view(),
+      gfx::Point(init_params.anchor_point_x, init_params.anchor_point_y),
+      params_);
+
+#ifdef USE_AURA
   SetPaintToLayer(true);
   SetFillsBoundsOpaquely(true);
 
-  bubble_border_ = new TrayBubbleBorder(this, anchor_view(), params_);
-
   bubble_content_mask_.reset(
       new TrayBubbleContentMask(bubble_border_->GetBorderCornerRadius() - 1));
+#endif  //USE_AURA
 }
 
 TrayBubbleView::~TrayBubbleView() {
   // Inform host items (models) that their views are being destroyed.
   if (delegate_)
     delegate_->BubbleViewDestroyed();
 }
 
 void TrayBubbleView::InitializeAndShowBubble() {
   // Must occur after call to BubbleDelegateView::CreateBubble().
-  SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
+  SetAlignment(params_.arrow_alignment);
   bubble_border_->UpdateArrowOffset();
 
+#ifdef USE_AURA
   layer()->parent()->SetMaskLayer(bubble_content_mask_->layer());
+#endif  // USE_AURA
 
   Show();
   UpdateBubble();
 }
 
 void TrayBubbleView::UpdateBubble() {
   SizeToContents();
+#ifdef USE_AURA
   bubble_content_mask_->layer()->SetBounds(layer()->bounds());
+#endif  // USE_AURA
   GetWidget()->GetRootView()->SchedulePaint();
 }
 
 void TrayBubbleView::SetMaxHeight(int height) {
   params_.max_height = height;
   if (GetWidget())
     SizeToContents();
 }
 
 void TrayBubbleView::SetWidth(int width) {
@@ skipping 79 matching lines @@
   }
 }
 
 void TrayBubbleView::ChildPreferredSizeChanged(View* child) {
   SizeToContents();
 }
 
 void TrayBubbleView::ViewHierarchyChanged(bool is_add,
                                           views::View* parent,
                                           views::View* child) {
+#ifdef USE_AURA
   if (is_add && child == this) {
     parent->SetPaintToLayer(true);
     parent->SetFillsBoundsOpaquely(true);
     parent->layer()->SetMasksToBounds(true);
   }
+#endif  // USE_AURA
 }
 
 }  // namespace views