Adding new maximize menu according to spec

ash/wm/workspace/frame_maximize_button.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/workspace/frame_maximize_button.h"
 
 #include "ash/launcher/launcher.h"
 #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"
 #include "grit/ui_resources.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
@@ skipping 77 matching lines @@
 }
 
 // FrameMaximizeButton ---------------------------------------------------------
 
 FrameMaximizeButton::FrameMaximizeButton(views::ButtonListener* listener,
                                          views::NonClientFrameView* frame)
     : ImageButton(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_)
     ProcessStartEvent(event);
   ImageButton::OnMousePressed(event);
   return true;
 }
 
 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) {
   if (is_snap_enabled_)
     ProcessUpdateEvent(event);
   return ImageButton::OnMouseDragged(event);
 }
 
 void FrameMaximizeButton::OnMouseReleased(const views::MouseEvent& event) {
   if (!ProcessEndEvent(event))
     ImageButton::OnMouseReleased(event);
+  maximizer_.reset();
 }
 
 void FrameMaximizeButton::OnMouseCaptureLost() {
   Cancel();
   ImageButton::OnMouseCaptureLost();
 }
 
 ui::GestureStatus FrameMaximizeButton::OnGestureEvent(
     const views::GestureEvent& event) {
   if (event.type() == ui::ET_GESTURE_TAP_DOWN) {
@@ skipping 25 matching lines @@
     }
   }
 
   return ImageButton::OnGestureEvent(event);
 }
 
 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.
   return ImageButton::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;
   press_location_ = event.location();
   exceeded_drag_threshold_ = false;
   update_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kUpdateDelayMS),
       this,
       &FrameMaximizeButton::UpdateSnapFromEventLocation);
@@ skipping 10 matching lines @@
   if (exceeded_drag_threshold_)
     UpdateSnap(event.location());
 }
 
 bool FrameMaximizeButton::ProcessEndEvent(const views::LocatedEvent& event) {
   update_timer_.Stop();
   UninstallEventFilter();
   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;
 
   SetState(BS_NORMAL);
   // SetState will not call SchedulePaint() if state was already set to
   // BS_NORMAL during a drag.
   SchedulePaint();
   phantom_window_.reset();
   Snap();
   return true;
 }
 
 void FrameMaximizeButton::Cancel() {
+  maximizer_.reset();
   UninstallEventFilter();
   is_snap_enabled_ = false;
   phantom_window_.reset();
   snap_sizer_.reset();
+  snap_type_ = SNAP_NONE;
   update_timer_.Stop();
   SchedulePaint();
 }
 
 void FrameMaximizeButton::InstallEventFilter() {
   if (escape_event_filter_.get())
     return;
 
   escape_event_filter_.reset(new EscapeEventFilter(this));
 }
 
 void FrameMaximizeButton::UninstallEventFilter() {
   escape_event_filter_.reset(NULL);
 }
 
 void FrameMaximizeButton::UpdateSnapFromEventLocation() {
   // If the drag threshold has been exceeded the snap location is up to date.
   if (exceeded_drag_threshold_)
     return;
   exceeded_drag_threshold_ = true;
   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_) {
     if (snap_sizer_.get()) {
       snap_sizer_->Update(LocationForSnapSizer(location));
       phantom_window_->Show(ScreenAsh::ConvertRectToScreen(
           frame_->GetWidget()->GetNativeView()->parent(),
           snap_sizer_->target_bounds()));
     }
     return;
@@ skipping 13 matching lines @@
         SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
     int grid_size = Shell::GetInstance()->GetGridSize();
     snap_sizer_.reset(new SnapSizer(frame_->GetWidget()->GetNativeWindow(),
                                     LocationForSnapSizer(location),
                                     snap_edge, grid_size));
   }
   if (!phantom_window_.get()) {
     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(
     const gfx::Point& location) const {
   int delta_x = location.x() - press_location_.x();
   int delta_y = location.y() - press_location_.y();
   if (!views::View::ExceededDragThreshold(delta_x, delta_y))
     return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE;
   else if (delta_x < 0 && delta_y > delta_x && delta_y < -delta_x)
     return SNAP_LEFT;
@@ skipping 38 matching lines @@
   return gfx::Rect();
 }
 
 gfx::Point FrameMaximizeButton::LocationForSnapSizer(
     const gfx::Point& location) const {
   gfx::Point result(location);
   views::View::ConvertPointToScreen(this, &result);
   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:
     case SNAP_RIGHT:
       if (frame_->GetWidget()->IsMaximized()) {
         ash::SetRestoreBoundsInScreen(frame_->GetWidget()->GetNativeWindow(),
                                       ScreenBoundsForType(snap_type_));
         frame_->GetWidget()->Restore();
       } else {
         frame_->GetWidget()->SetBounds(ScreenBoundsForType(snap_type_));
       }
       break;
     case SNAP_MAXIMIZE:
       frame_->GetWidget()->Maximize();
       break;
     case SNAP_MINIMIZE:
       frame_->GetWidget()->Minimize();
       break;
     case SNAP_RESTORE:
       frame_->GetWidget()->Restore();
       break;
     case SNAP_NONE:
       NOTREACHED();
   }
 }
 
+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