Adding new maximize menu according to spec

ash/wm/workspace/frame_maximize_button.cc

Index: ash/wm/workspace/frame_maximize_button.cc
diff --git a/ash/wm/workspace/frame_maximize_button.cc b/ash/wm/workspace/frame_maximize_button.cc
index 213f4d21228762557d251138335c7d1dfec32277..986ad5b615700d22dcdcf42b2f72a28e6c7fbdde 100644
--- a/ash/wm/workspace/frame_maximize_button.cc
+++ b/ash/wm/workspace/frame_maximize_button.cc
@@ -8,6 +8,7 @@
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
+#include "ash/wm/maximize_bubble_controller.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "grit/ash_strings.h"
@@ -105,15 +106,32 @@ FrameMaximizeButton::FrameMaximizeButton(views::ButtonListener* listener,
       frame_(frame),
       is_snap_enabled_(false),
       exceeded_drag_threshold_(false),
-      snap_type_(SNAP_NONE) {
+      window_(NULL),
+      snap_type_(SNAP_NONE),
+      maximizer_(NULL) {

[sky, 2012/08/02 18:30:30]

no need for this.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

   // TODO(sky): nuke this. It's temporary while we don't have good images.
   SetImageAlignment(ALIGN_LEFT, ALIGN_BOTTOM);
-  SetTooltipText(l10n_util::GetStringUTF16(IDS_FRAME_MAXIMIZE_BUTTON_TOOLTIP));
 }
 
 FrameMaximizeButton::~FrameMaximizeButton() {
 }
 
+void FrameMaximizeButton::OnWindowBoundsChanged(
+    aura::Window* window,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds) {
+  Cancel();
+}
+
+void FrameMaximizeButton::OnWindowDestroying(aura::Window* window) {
+  maximizer_.reset();
+  if (window_) {
+    CHECK_EQ(window_, window);
+    window_->RemoveObserver(this);
+    window_ = NULL;
+  }
+}
+
 bool FrameMaximizeButton::OnMousePressed(const views::MouseEvent& event) {
   is_snap_enabled_ = event.IsLeftMouseButton();
   if (is_snap_enabled_)
@@ -124,10 +142,29 @@ bool FrameMaximizeButton::OnMousePressed(const views::MouseEvent& event) {
 
 void FrameMaximizeButton::OnMouseEntered(const views::MouseEvent& event) {
   ImageButton::OnMouseEntered(event);
+  if (!maximizer_.get()) {
+    if (!window_ && parent() && parent()->GetWidget()) {

[sky, 2012/08/02 18:30:30]

I think GetWidget() should be a DCHECK here (especially since line 152 would
crash if it returns NULL).

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+      window_ = parent()->GetWidget()->GetNativeWindow();
+      window_->AddObserver(this);
+    }
+    maximizer_.reset(new MaximizeBubbleController(
+        this,
+        frame_->GetWidget()->IsMaximized()));

[sky, 2012/08/02 18:30:30]

This should be consistent with 146/147.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Ok

+  }
 }
 
 void FrameMaximizeButton::OnMouseExited(const views::MouseEvent& event) {
   ImageButton::OnMouseExited(event);
+  // Remove the bubble menu when the button is not pressed and the mouse is not
+  // within the bubble.
+  if (!is_snap_enabled_ && maximizer_.get() && maximizer_->GetMenuWindow()) {
+    gfx::Point screen_location = gfx::Screen::GetCursorScreenPoint();

[sky, 2012/08/02 18:30:30]

The event has a location, can't you use it?

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

First off: I am using the mouse coordinate here and somehow I think it is faster
to simply get this then copying the coordinate and then calculating the screen
coordinate. But I tried it and using

gfx::Point screen_location(event.location());
views::View::ConvertPointToScreen(this, &screen_location);

behaved poorly (the menu was flickering). Not sure why that is though.

+    if (!maximizer_->GetMenuWindow()->bounds().Contains(screen_location)) {
+      maximizer_.reset();
+      // Make sure that all remaining snap hover states get removed.
+      SnapButtonHovered(SNAP_NONE);
+    }
+  }
 }
 
 bool FrameMaximizeButton::OnMouseDragged(const views::MouseEvent& event) {
@@ -139,6 +176,7 @@ bool FrameMaximizeButton::OnMouseDragged(const views::MouseEvent& event) {
 void FrameMaximizeButton::OnMouseReleased(const views::MouseEvent& event) {
   if (!ProcessEndEvent(event))
     ImageButton::OnMouseReleased(event);
+  maximizer_.reset();
 }
 
 void FrameMaximizeButton::OnMouseCaptureLost() {
@@ -184,44 +222,16 @@ gfx::ImageSkia FrameMaximizeButton::GetImageToPaint() {
   if (is_snap_enabled_) {
     int id = 0;
     if (frame_->GetWidget()->IsMaximized()) {
-      switch (snap_type_) {
-        case SNAP_LEFT:
-          id = IDR_AURA_WINDOW_MAXIMIZED_SNAP_LEFT_P;
-          break;
-        case SNAP_RIGHT:
-          id = IDR_AURA_WINDOW_MAXIMIZED_SNAP_RIGHT_P;
-          break;
-        case SNAP_MAXIMIZE:
-        case SNAP_RESTORE:
-        case SNAP_NONE:
-          id = IDR_AURA_WINDOW_MAXIMIZED_SNAP_P;
-          break;
-        case SNAP_MINIMIZE:
-          id = IDR_AURA_WINDOW_MAXIMIZED_SNAP_MINIMIZE_P;
-          break;
-        default:
-          NOTREACHED();
-      }
-    } else {
-      switch (snap_type_) {
-        case SNAP_LEFT:
-          id = IDR_AURA_WINDOW_SNAP_LEFT_P;
-          break;
-        case SNAP_RIGHT:
-          id = IDR_AURA_WINDOW_SNAP_RIGHT_P;
-          break;
-        case SNAP_MAXIMIZE:
-        case SNAP_RESTORE:
-        case SNAP_NONE:
-          id = IDR_AURA_WINDOW_SNAP_P;
-          break;
-        case SNAP_MINIMIZE:
-          id = IDR_AURA_WINDOW_SNAP_MINIMIZE_P;
-          break;
-        default:
-          NOTREACHED();
-      }
-    }
+      // TODO(SKUHNE): Remove old bitmaps as soon as the final artwork comes in:
+      // IDR_AURA_WINDOW_MAXIMIZED_SNAP_LEFT_P
+      // IDR_AURA_WINDOW_MAXIMIZED_SNAP_RIGHT_P
+      // IDR_AURA_WINDOW_MAXIMIZED_SNAP_MINIMIZE_P
+      // IDR_AURA_WINDOW_SNAP_LEFT_P
+      // IDR_AURA_WINDOW_SNAP_RIGHT_P
+      // IDR_AURA_WINDOW_SNAP_MINIMIZE_P
+      id = IDR_AURA_WINDOW_MAXIMIZED_SNAP_P;
+    } else
+      id = IDR_AURA_WINDOW_SNAP_P;
     return *ResourceBundle::GetSharedInstance().GetImageNamed(id).ToImageSkia();
   }
   // Hot and pressed states handled by regular ImageButton.
@@ -230,6 +240,15 @@ gfx::ImageSkia FrameMaximizeButton::GetImageToPaint() {
 
 void FrameMaximizeButton::ProcessStartEvent(const views::LocatedEvent& event) {
   DCHECK(is_snap_enabled_);
+  // Prepare the help / halo menu.

[msw, 2012/08/02 18:56:59]

nit: what's " help / halo"? Update comment.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+  if (!maximizer_.get()) {
+    maximizer_.reset(new MaximizeBubbleController(
+        this,
+        frame_->GetWidget()->IsMaximized()));
+  } else {
+    // If the menu did not show up yet, we delay it even a bit more.
+    maximizer_->DelayCreation();
+  }
   snap_sizer_.reset(NULL);
   InstallEventFilter();
   snap_type_ = SNAP_NONE;
@@ -260,6 +279,11 @@ bool FrameMaximizeButton::ProcessEndEvent(const views::LocatedEvent& event) {
   bool should_snap = is_snap_enabled_;
   is_snap_enabled_ = false;
 
+  // Remove our help / halo menu if the mouse cursor is not still over it.

[sky, 2012/08/02 18:30:30]

help/halo -> bubble

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+  gfx::Point screen_location = gfx::Screen::GetCursorScreenPoint();

[sky, 2012/08/02 18:30:30]

event has a location, use it.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

As stated in the comment: an event comes to an end, but the mouse cursor is
independent of it. To avoid closing the menu while the mouse cursor is still
over it (note it won't come back until the mouse re-enters the button) I check
explicitly against the mouse position.

+  if (!GetBoundsInScreen().Contains(screen_location))
+    maximizer_.reset();

[sky, 2012/08/02 18:30:30]

You sure we don't want to reset always? In particular seems like it would be
annoying for gestures that could leave the bubble up.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

See comment above.

+
   if (!should_snap || snap_type_ == SNAP_NONE)
     return false;
 
@@ -273,10 +297,12 @@ bool FrameMaximizeButton::ProcessEndEvent(const views::LocatedEvent& event) {
 }
 
 void FrameMaximizeButton::Cancel() {
+  maximizer_.reset();
   UninstallEventFilter();
   is_snap_enabled_ = false;
   phantom_window_.reset();
   snap_sizer_.reset();
+  snap_type_ = SNAP_NONE;
   update_timer_.Stop();
   SchedulePaint();
 }
@@ -300,6 +326,42 @@ void FrameMaximizeButton::UpdateSnapFromEventLocation() {
   UpdateSnap(press_location_);
 }
 
+void FrameMaximizeButton::SnapButtonHovered(SnapType type) {
+  // Make sure to only show hover operations when no button is pressed and
+  // a similar snap operation in progress does not get re-applied.
+  if (is_snap_enabled_ || (type == snap_type_ && snap_sizer_.get()))
+    return;
+  // Prime the mouse location with the center of the (local) button.
+  press_location_ = gfx::Point(width() / 2, height() / 2);
+  // Then get an adjusted mouse position to initiate the effect.
+  gfx::Point location = press_location_;
+  switch (type) {
+    case SNAP_LEFT:
+      location.set_x(location.x() - width());
+      break;
+    case SNAP_RIGHT:
+      location.set_x(location.x() + width());
+      break;
+    case SNAP_MINIMIZE:
+      location.set_y(location.y() + height());
+      break;
+    case SNAP_MAXIMIZE:
+    case SNAP_RESTORE:
+      break;
+    case SNAP_NONE:
+      snap_type_ = type;

[sky, 2012/08/02 18:30:30]

Cancel()? Maybe you can't because you don't want the maximizer reset. If that's
the case add a boolean to Cancel for maximizer.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

There are two distinct operations: Button hover and menu operation (and they
should not interfere). At least one thing should not happen for sure: the menu
closes when no button is hovered. So added a new parameter as requested.

+      snap_sizer_.reset();
+      SchedulePaint();
+      phantom_window_.reset();
+      return;
+    default:
+      // We should not come here.
+      DCHECK(false);

[sky, 2012/08/02 18:30:30]

NOTREACHED

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+      return;
+  }
+  UpdateSnap(location);
+}
+
 void FrameMaximizeButton::UpdateSnap(const gfx::Point& location) {
   SnapType type = SnapTypeForLocation(location);
   if (type == snap_type_) {
@@ -333,7 +395,13 @@ void FrameMaximizeButton::UpdateSnap(const gfx::Point& location) {
     phantom_window_.reset(new internal::PhantomWindowController(
                               frame_->GetWidget()->GetNativeWindow()));
   }
+  if (maximizer_.get())
+    phantom_window_->set_phantom_below_window(maximizer_->GetMenuWindow());
+
   phantom_window_->Show(ScreenBoundsForType(snap_type_));
+
+  if (maximizer_.get())

[msw, 2012/08/02 18:56:59]

nit: if the order here isn't critical, combine this with the if block above.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Not for this menu - but for the other one. Okay - changed (will re-introduce
then later again)

+    maximizer_->SetMenuState(snap_type_);
 }
 
 FrameMaximizeButton::SnapType FrameMaximizeButton::SnapTypeForLocation(
@@ -392,6 +460,17 @@ gfx::Point FrameMaximizeButton::LocationForSnapSizer(
   return result;
 }
 
+void FrameMaximizeButton::ExecuteSnapAndCloseMenu(SnapType snap_type) {

[sky, 2012/08/02 18:30:30]

Make sure order matches header.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+  snap_type_ = snap_type;
+  Snap();

[sky, 2012/08/02 18:30:30]

DCHECK_NE(snap_type_, SNAP_NONE).

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

I have to admit that I won't see any harm done if this would happen, but sure -
otherwise it'll scream later (for no real reason) :)

+  // Remove any pending snap previews.
+  SnapButtonHovered(SNAP_NONE);
+  // At this point the operation has been performed and the menu should be
+  // closed (due to the resize operation). If not, it'll get now closed.
+  if (maximizer_.get())

[sky, 2012/08/02 18:30:30]

no if. and comment is misleading since a minimize won't change the bounds.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+    maximizer_.reset();
+}
+
 void FrameMaximizeButton::Snap() {
   switch (snap_type_) {
     case SNAP_LEFT:
@@ -418,4 +497,9 @@ void FrameMaximizeButton::Snap() {
   }
 }
 
+void FrameMaximizeButton::DestroyMaximizeMenu() {

[sky, 2012/08/02 18:30:30]

Make order match header.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+  if (maximizer_.get())
+    maximizer_.reset();

[sky, 2012/08/02 18:30:30]

No need for the if. maximizer_.reset() does the right thing.

[Mr4D (OOO till 08-26), 2012/08/02 23:10:38]

Done.

+  }
+
 }  // namespace ash