Fixing many problems around the maximize bubble

ash/wm/maximize_bubble_controller.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 "ash/wm/maximize_bubble_controller.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/workspace/frame_maximize_button.h"
 #include "base/timer.h"
 #include "grit/ash_strings.h"
 #include "grit/ui_resources.h"
+#include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/window.h"
+#include "ui/base/animation/animation.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/bubble/bubble_delegate.h"
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/events/event.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/mouse_watcher.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 // The spacing between two buttons.
 const int kLayoutSpacing = -1;
 
 // The background color.
 const SkColor kBubbleBackgroundColor = 0xc8141414;
 
 // The text color within the bubble.
 const SkColor kBubbleTextColor = SK_ColorWHITE;
 
 // The line width of the bubble.
 const int kLineWidth = 1;
 
+// The spacing for the top and bottom of the info label.
+const int kLabelSpacing = 4;
+
 // The pixel dimensions of the arrow.
 const int kArrowHeight = 10;
 const int kArrowWidth = 20;
 
 // The delay of the bubble appearance.
 const int kBubbleAppearanceDelayMS = 200;
-const int kAnimationDurationForPopupMS = 200;
+
+// The animation offset in y for the bubble when appearing.
+const int kBubbleAnimationOffsetY = 5;
 
 class MaximizeBubbleBorder : public views::BubbleBorder {
  public:
   MaximizeBubbleBorder(views::View* content_view, views::View* anchor);
 
   virtual ~MaximizeBubbleBorder() {}
 
+  // Get the mouse active area of the window.
+  void GetMask(gfx::Path* mask);
+
   // Overridden from views::BubbleBorder to match the design specs.
   virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
                               const gfx::Size& contents_size) const OVERRIDE;
 
   // Overridden from views::Border.
   virtual void Paint(const views::View& view,
                      gfx::Canvas* canvas) const OVERRIDE;
+
  private:
-  views::View* anchor_;
+  // Note: Animations can continue after then main window frame was destroyed.
+  // To avoid this problem, the owning screen metrics get extracted upon
+  // creation.
+  gfx::Size anchor_size_;
+  gfx::Point anchor_screen_origin_;
   views::View* content_view_;
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeBubbleBorder);
 };
 
 MaximizeBubbleBorder::MaximizeBubbleBorder(views::View* content_view,
                                            views::View* anchor)
     : views::BubbleBorder(views::BubbleBorder::TOP_RIGHT,
                           views::BubbleBorder::NO_SHADOW),
-      anchor_(anchor),
+      anchor_size_(anchor->size()),
+      anchor_screen_origin_(0,0),
       content_view_(content_view) {
+  views::View::ConvertPointToScreen(anchor, &anchor_screen_origin_);
   set_alignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
 }
 
+void MaximizeBubbleBorder::GetMask(gfx::Path* mask) {
+  gfx::Insets inset;
+  GetInsets(&inset);
+  // Note: Even though the tip could be added as activatable, it is left out
+  // since it would not change the action behavior in any way plus it makes
+  // more sense to keep the focus on the underlying button for clicks.
+  int left = inset.left() - kLineWidth;
+  int right = inset.left() + content_view_->width() + kLineWidth;
+  int top = inset.top() - kLineWidth;
+  int bottom = inset.top() + content_view_->height() + kLineWidth;
+  mask->moveTo(left, top);
+  mask->lineTo(right, top);
+  mask->lineTo(right, bottom);
+  mask->lineTo(left, bottom);
+  mask->lineTo(left, top);
+  mask->close();
+}
+
 gfx::Rect MaximizeBubbleBorder::GetBounds(
     const gfx::Rect& position_relative_to,
     const gfx::Size& contents_size) const {
   gfx::Size border_size(contents_size);
   gfx::Insets insets;
   GetInsets(&insets);
   border_size.Enlarge(insets.width(), insets.height());
 
   // Position the bubble to center the box on the anchor.
-  int x = (-border_size.width() + anchor_->width()) / 2;
+  int x = (-border_size.width() + anchor_size_.width()) / 2;
   // Position the bubble under the anchor, overlapping the arrow with it.
-  int y = anchor_->height() - insets.top();
+  int y = anchor_size_.height() - insets.top();
 
-  gfx::Point view_origin(x, y);
-  views::View::ConvertPointToScreen(anchor_, &view_origin);
+  gfx::Point view_origin(x + anchor_screen_origin_.x(),
+                         y + anchor_screen_origin_.y());
 
   return gfx::Rect(view_origin, border_size);
 }
 
 void MaximizeBubbleBorder::Paint(const views::View& view,
                                  gfx::Canvas* canvas) const {
   gfx::Insets inset;
   GetInsets(&inset);
 
   // Draw the border line around everything.
@@ skipping 77 matching lines @@
                                          public views::MouseWatcherListener {
  public:
   explicit Bubble(MaximizeBubbleController* owner);
   virtual ~Bubble() {}
 
   // The window of the menu under which the SnapSizer will get created.
   aura::Window* GetBubbleWindow();
 
   // Overridden from views::BubbleDelegateView.
   virtual gfx::Rect GetAnchorRect() OVERRIDE;
+  virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE;
+
+  // Overridden from views::WidgetDelegateView.
+  virtual bool HasHitTestMask() const OVERRIDE;
+  virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE;
 
   // Implementation of MouseWatcherListener.
   virtual void MouseMovedOutOfHost();
 
   // Implementation of MouseWatcherHost.
   virtual bool Contains(const gfx::Point& screen_point,
                         views::MouseWatcherHost::MouseEventType type);
 
   // Overridden from views::View.
   virtual gfx::Size GetPreferredSize() OVERRIDE;
@@ skipping 19 matching lines @@
 
   // Our owning class.
   MaximizeBubbleController* owner_;
 
   // The widget which contains our menu and the bubble border.
   views::Widget* bubble_widget_;
 
   // The content accessor of the menu.
   BubbleContentsView* contents_view_;
 
+  // The bubble border.
+  MaximizeBubbleBorder* bubble_border_;
+
+  // The rectangle before the animation starts.
+  gfx::Rect initial_position_;
+
   // The mouse watcher which takes care of out of window hover events.
   scoped_ptr<views::MouseWatcher> mouse_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(Bubble);
 };
 
 // A class that creates all buttons and put them into a view.
 class BubbleContentsButtonRow : public views::View,
                                 public views::ButtonListener {
  public:
@@ skipping 66 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BubbleDialogButton);
 };
 
 MaximizeBubbleController::Bubble::Bubble(MaximizeBubbleController* owner)
     : views::BubbleDelegateView(owner->frame_maximize_button(),
                                 views::BubbleBorder::TOP_RIGHT),
       shutting_down_(false),
       owner_(owner),
       bubble_widget_(NULL),
-      contents_view_(NULL) {
+      contents_view_(NULL),
+      bubble_border_(NULL) {
   set_margins(gfx::Insets());
 
   // The window needs to be owned by the root so that the SnapSizer does not
   // cover it upon animation.
   aura::Window* parent = Shell::GetContainer(
       Shell::GetActiveRootWindow(),
       internal::kShellWindowId_LauncherContainer);
   set_parent_window(parent);
 
   set_notify_enter_exit_on_child(true);
@@ skipping 11 matching lines @@
   contents_view_ = new BubbleContentsView(this);
   AddChildView(contents_view_);
 
   // Note that the returned widget has an observer which points to our
   // functions.
   bubble_widget_ = views::BubbleDelegateView::CreateBubble(this);
 
   SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble_widget_->non_client_view()->frame_view()->set_background(NULL);
 
-  MaximizeBubbleBorder* bubble_border = new MaximizeBubbleBorder(
-      this,
-      anchor_view());
-  GetBubbleFrameView()->SetBubbleBorder(bubble_border);
+  bubble_border_ = new MaximizeBubbleBorder(this, anchor_view());
+  GetBubbleFrameView()->SetBubbleBorder(bubble_border_);
   GetBubbleFrameView()->set_background(NULL);
 
   // Recalculate size with new border.
   SizeToContents();
 
-  // Setup animation.
-  ash::SetWindowVisibilityAnimationType(
-      bubble_widget_->GetNativeWindow(),
-      ash::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
-  ash::SetWindowVisibilityAnimationTransition(
-      bubble_widget_->GetNativeWindow(),
-      ash::ANIMATE_BOTH);
-  ash::SetWindowVisibilityAnimationDuration(
-      bubble_widget_->GetNativeWindow(),
-      base::TimeDelta::FromMilliseconds(kAnimationDurationForPopupMS));
+  StartFade(true);
 
-  Show();
-  // We don't want to lose the focus on our parent window because the button
-  // would otherwise lose the highlight when the "helper bubble" is shown.
-  views::Widget* widget =
-      owner_->frame_maximize_button()->parent()->GetWidget();
-  if (widget) {
-    aura::Window* parent_window = widget->GetNativeWindow();
-    parent_window->GetFocusManager()->SetFocusedWindow(parent_window, NULL);
-  }
   mouse_watcher_.reset(new views::MouseWatcher(
       new BubbleMouseWatcherHost(this),
       this));
   mouse_watcher_->Start();
 }
 
 bool BubbleMouseWatcherHost::Contains(
     const gfx::Point& screen_point,
     views::MouseWatcherHost::MouseEventType type) {
   return bubble_->Contains(screen_point, type);
 }
 
 aura::Window* MaximizeBubbleController::Bubble::GetBubbleWindow() {
   return bubble_widget_ ? bubble_widget_->GetNativeWindow() : NULL;
 }
 
 gfx::Rect MaximizeBubbleController::Bubble::GetAnchorRect() {
   if (!owner_)
     return gfx::Rect();
 
   gfx::Rect anchor_rect =
       owner_->frame_maximize_button()->GetBoundsInScreen();
   return anchor_rect;
 }
 
+void MaximizeBubbleController::Bubble::AnimationProgressed(
+    const ui::Animation* animation) {
+  // First do everything needed for the fade by calling the base function.
+  BubbleDelegateView::AnimationProgressed(animation);
+  // When fading in we are done.
+  if (!shutting_down_)
+    return;
+  // Upon fade out an additional shift is required.
+  int shift = animation->CurrentValueBetween(kBubbleAnimationOffsetY, 0);
+  gfx::Rect rect = initial_position_;
+
+  rect.set_y(rect.y() + shift);
+  bubble_widget_->GetNativeWindow()->SetBounds(rect);
+}
+
+bool MaximizeBubbleController::Bubble::HasHitTestMask() const {
+  return bubble_border_ != NULL;
+}
+
+void MaximizeBubbleController::Bubble::GetHitTestMask(gfx::Path* mask) const {
+  DCHECK(mask);
+  DCHECK(bubble_border_);
+  bubble_border_->GetMask(mask);
+}
+
 void MaximizeBubbleController::Bubble::MouseMovedOutOfHost() {
   if (!owner_ || shutting_down_)
     return;
   // When we leave the bubble, we might be still be in gesture mode or over
   // the maximize button. So only close if none of the other cases apply.
   if (!owner_->frame_maximize_button()->is_snap_enabled()) {
     gfx::Point screen_location = gfx::Screen::GetCursorScreenPoint();
     if (!owner_->frame_maximize_button()->GetBoundsInScreen().Contains(
         screen_location)) {
         owner_->RequestDestructionThroughOwner();
     }
   }
 }
 
 bool MaximizeBubbleController::Bubble::Contains(
     const gfx::Point& screen_point,
     views::MouseWatcherHost::MouseEventType type) {
   if (!owner_ || shutting_down_)
     return false;
+  bool inside_button =
+      owner_->frame_maximize_button()->GetBoundsInScreen().Contains(
+          screen_point);
+  if (!owner_->frame_maximize_button()->is_snap_enabled() && inside_button) {
+    SetSnapType(controller()->is_maximized() ? SNAP_RESTORE : SNAP_MAXIMIZE);
+    return true;
+  }
   // Check if either a gesture is taking place (=> bubble stays no matter what
   // the mouse does) or the mouse is over the maximize button or the bubble
   // content.
   return (owner_->frame_maximize_button()->is_snap_enabled() ||
-          owner_->frame_maximize_button()->GetBoundsInScreen().Contains(
-              screen_point) ||
+          inside_button ||
           contents_view_->GetBoundsInScreen().Contains(screen_point));
 }
 
 gfx::Size MaximizeBubbleController::Bubble::GetPreferredSize() {
   return contents_view_->GetPreferredSize();
 }
 
 void MaximizeBubbleController::Bubble::OnWidgetClosing(views::Widget* widget) {
   if (bubble_widget_ != widget)
     return;
@@ skipping 12 matching lines @@
   anchor_widget()->RemoveObserver(this);
 }
 
 void MaximizeBubbleController::Bubble::ControllerRequestsCloseAndDelete() {
   // This only gets called from the owning base class once it is deleted.
   if (shutting_down_)
     return;
   shutting_down_ = true;
   owner_ = NULL;
 
-  // Close the widget asynchronously.
-  bubble_widget_->Close();
+  // Close the widget asynchronously after the hide animation is finished.
+  initial_position_ = bubble_widget_->GetNativeWindow()->bounds();
+  StartFade(false);
 }
 
 void MaximizeBubbleController::Bubble::SetSnapType(SnapType snap_type) {
   if (contents_view_)
     contents_view_->SetSnapType(snap_type);
 }
 
 BubbleContentsButtonRow::BubbleContentsButtonRow(
     MaximizeBubbleController::Bubble* bubble)
     : bubble_(bubble),
@@ skipping 64 matching lines @@
       views::Background::CreateSolidBackground(kBubbleBackgroundColor));
 
   buttons_view_ = new BubbleContentsButtonRow(bubble);
   AddChildView(buttons_view_);
 
   label_view_ = new views::Label();
   SetSnapType(SNAP_NONE);
   label_view_->SetHorizontalAlignment(views::Label::ALIGN_CENTER);
   label_view_->SetBackgroundColor(kBubbleBackgroundColor);
   label_view_->SetEnabledColor(kBubbleTextColor);
+  label_view_->set_border(views::Border::CreateEmptyBorder(
+      kLabelSpacing, 0, kLabelSpacing, 0));
   AddChildView(label_view_);
 }
 
 // Set the label content to reflect the currently selected |snap_type|.
 // This function can be executed through the frame maximize button as well as
 // through hover operations.
 void BubbleContentsView::SetSnapType(SnapType snap_type) {
   if (!bubble_->controller())
     return;
 
@@ skipping 115 matching lines @@
   button_row_->ButtonHovered(this);
   views::ImageButton::OnMouseEntered(event);
 }
 
 void BubbleDialogButton::OnMouseExited(const views::MouseEvent& event) {
   button_row_->ButtonHovered(NULL);
   views::ImageButton::OnMouseExited(event);
 }
 
 }  // namespace ash