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 46 matching lines @@
 
 FrameMaximizeButton::EscapeEventFilter::~EscapeEventFilter() {
   Shell::GetInstance()->RemoveEnvEventFilter(this);
 }
 
 bool FrameMaximizeButton::EscapeEventFilter::PreHandleKeyEvent(
     aura::Window* target,
     aura::KeyEvent* event) {
   if (event->type() == ui::ET_KEY_PRESSED &&
       event->key_code() == ui::VKEY_ESCAPE) {
-    button_->Cancel();
+    button_->Cancel(false);
   }
   return false;
 }
 
 bool FrameMaximizeButton::EscapeEventFilter::PreHandleMouseEvent(
     aura::Window* target,
     aura::MouseEvent* event) {
   return false;
 }
 
@@ skipping 10 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_(workspace::SNAP_NONE) {
   // 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(false);
+}
+
+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()) {
+    DCHECK(parent()->GetWidget());
+    if (!window_ && parent()) {

[sky, 2012/08/03 19:42:00]

remove parent() here

[Mr4D (OOO till 08-26), 2012/08/03 20:39:28]

Okay. I don't quite get this. Why is the widget of the button the complete
window? Done.

[sky, 2012/08/03 23:10:17]

That's how the hierarchy is set up. Most views share the same widget.

+      window_ = parent()->GetWidget()->GetNativeWindow();

[sky, 2012/08/03 19:42:00]

remove parent() here

[Mr4D (OOO till 08-26), 2012/08/03 20:39:28]

Done.

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

[sky, 2012/08/03 19:42:00]

remove frame_ here

[Mr4D (OOO till 08-26), 2012/08/03 20:39:28]

Fascinating. How is it possible that the widget of the button is the same widget
as the frame_? Done.

+  }
 }
 
 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_->GetBubbleWindow()) {
+    gfx::Point screen_location = gfx::Screen::GetCursorScreenPoint();
+    if (!maximizer_->GetBubbleWindow()->bounds().Contains(screen_location)) {

[sky, 2012/08/03 19:42:00]

bounds() is not necessarily in the same coordinates as GetCursorScreenPoint.

[Mr4D (OOO till 08-26), 2012/08/03 20:39:28]

The Bubble window is a top level window and the coordinates should therefore be
relative to the screen. That said: I changed it now to use GetBoundsInScreen.
Done.

[sky, 2012/08/03 23:10:17]

toplevel window and screen coordinates are two different things. 

+      maximizer_.reset();
+      // Make sure that all remaining snap hover states get removed.
+      SnapButtonHovered(workspace::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();
+  Cancel(false);
   ImageButton::OnMouseCaptureLost();
 }
 
 ui::GestureStatus FrameMaximizeButton::OnGestureEvent(
     const views::GestureEvent& event) {
   if (event.type() == ui::ET_GESTURE_TAP_DOWN) {
     is_snap_enabled_ = true;
     ProcessStartEvent(event);
     return ui::GESTURE_STATUS_CONSUMED;
   }
@@ skipping 17 matching lines @@
     if (event.type() == ui::ET_GESTURE_SCROLL_UPDATE ||
         event.type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       ProcessUpdateEvent(event);
       return ui::GESTURE_STATUS_CONSUMED;
     }
   }
 
   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();
-      }
-    }
-    return *ResourceBundle::GetSharedInstance().GetImageNamed(id).ToImageSkia();
+void FrameMaximizeButton::SnapButtonHovered(workspace::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 workspace::SNAP_LEFT:
+      location.set_x(location.x() - width());
+      break;
+    case workspace::SNAP_RIGHT:
+      location.set_x(location.x() + width());
+      break;
+    case workspace::SNAP_MINIMIZE:
+      location.set_y(location.y() + height());
+      break;
+    case workspace::SNAP_MAXIMIZE:
+    case workspace::SNAP_RESTORE:
+      break;
+    case workspace::SNAP_NONE:
+      Cancel(true);
+      return;
+    default:
+      // We should not come here.
+      NOTREACHED();
   }
-  // Hot and pressed states handled by regular ImageButton.
-  return ImageButton::GetImageToPaint();
+  UpdateSnap(location);
+}
+
+void FrameMaximizeButton::ExecuteSnapAndCloseMenu(
+    workspace::SnapType snap_type) {
+  DCHECK_NE(snap_type_, workspace::SNAP_NONE);
+  snap_type_ = snap_type;
+  Snap();
+  // Remove any pending snap previews.
+  SnapButtonHovered(workspace::SNAP_NONE);
+  // At this point the operation has been performed and the menu should be
+  // closed - if not, it'll get now closed.
+  maximizer_.reset();
+}
+
+void FrameMaximizeButton::DestroyMaximizeMenu() {
+  maximizer_.reset();
 }
 
 void FrameMaximizeButton::ProcessStartEvent(const views::LocatedEvent& event) {
   DCHECK(is_snap_enabled_);
+  // Prepare the help menu.
+  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;
+  snap_type_ = workspace::SNAP_NONE;
   press_location_ = event.location();
   exceeded_drag_threshold_ = false;
   update_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kUpdateDelayMS),
       this,
       &FrameMaximizeButton::UpdateSnapFromEventLocation);
 }
 
 void FrameMaximizeButton::ProcessUpdateEvent(const views::LocatedEvent& event) {
   DCHECK(is_snap_enabled_);
   int delta_x = event.x() - press_location_.x();
   int delta_y = event.y() - press_location_.y();
   if (!exceeded_drag_threshold_) {
     exceeded_drag_threshold_ =
         views::View::ExceededDragThreshold(delta_x, delta_y);
   }
   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;
 
-  if (!should_snap || snap_type_ == SNAP_NONE)
+  // Remove our help menu if the mouse cursor is not still over it.
+  gfx::Point screen_location = gfx::Screen::GetCursorScreenPoint();

[sky, 2012/08/03 19:42:00]

ProcessEndEvent may be invoked from a gesture event, in which case this doesn't
make sense. If we get here from a touch event you should always destroy the
maximizer.

[Mr4D (OOO till 08-26), 2012/08/03 20:39:28]

As said in your earlier review: The idea is to keep the menu open if the mouse
is also over the button. This makes sense since the menu would otherwise not
show up until the user leaves and re-enters the button. Discussing this
yesterday it made sense to you. Still want to get it removed?

[sky, 2012/08/03 20:43:08]

We hide the mouse cursor when you touch, so it doesn't make sense to do anything
based on the mouse when in touch. Lets say you touch the button and at the end
of the gesture the mouse happens to be in the button. This would result in the
maximizer staying around when the mouse cursor isn't visible. That would be
confusing.

[Mr4D (OOO till 08-26), 2012/08/03 20:47:31]

I suppose it is either way confusing. Okay, will do as you were asking for.

+  if (!GetBoundsInScreen().Contains(screen_location))
+    maximizer_.reset();
+
+  if (!should_snap || snap_type_ == workspace::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() {
-  UninstallEventFilter();
-  is_snap_enabled_ = false;
+void FrameMaximizeButton::Cancel(bool keep_menu_open) {
+  if (!keep_menu_open) {
+    maximizer_.reset();
+    UninstallEventFilter();
+    is_snap_enabled_ = false;
+  }
   phantom_window_.reset();
   snap_sizer_.reset();
+  snap_type_ = workspace::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::UpdateSnap(const gfx::Point& location) {
-  SnapType type = SnapTypeForLocation(location);
+  workspace::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;
   }
 
   snap_type_ = type;
   snap_sizer_.reset();
   SchedulePaint();
 
-  if (snap_type_ == SNAP_NONE) {
+  if (snap_type_ == workspace::SNAP_NONE) {
     phantom_window_.reset();
     return;
   }
 
-  if (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT) {
-    SnapSizer::Edge snap_edge = snap_type_ == SNAP_LEFT ?
+  if (snap_type_ == workspace::SNAP_LEFT ||
+      snap_type_ == workspace::SNAP_RIGHT) {
+    SnapSizer::Edge snap_edge = snap_type_ == workspace::SNAP_LEFT ?
         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_->GetBubbleWindow());
+    maximizer_->SetSnapType(snap_type_);
+  }
   phantom_window_->Show(ScreenBoundsForType(snap_type_));
 }
 
-FrameMaximizeButton::SnapType FrameMaximizeButton::SnapTypeForLocation(
+workspace::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;
+    return !frame_->GetWidget()->IsMaximized() ? workspace::SNAP_MAXIMIZE :
+        workspace::SNAP_RESTORE;
   else if (delta_x < 0 && delta_y > delta_x && delta_y < -delta_x)
-    return SNAP_LEFT;
+    return workspace::SNAP_LEFT;
   else if (delta_x > 0 && delta_y > -delta_x && delta_y < delta_x)
-    return SNAP_RIGHT;
+    return workspace::SNAP_RIGHT;
   else if (delta_y > 0)
-    return SNAP_MINIMIZE;
-  return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE;
+    return workspace::SNAP_MINIMIZE;
+  return !frame_->GetWidget()->IsMaximized() ? workspace::SNAP_MAXIMIZE :
+      workspace::SNAP_RESTORE;
 }
 
-gfx::Rect FrameMaximizeButton::ScreenBoundsForType(SnapType type) const {
+gfx::Rect FrameMaximizeButton::ScreenBoundsForType(
+    workspace::SnapType type) const {
   aura::Window* window = frame_->GetWidget()->GetNativeWindow();
   switch (type) {
-    case SNAP_LEFT:
-    case SNAP_RIGHT:
+    case workspace::SNAP_LEFT:
+    case workspace::SNAP_RIGHT:
       return ScreenAsh::ConvertRectToScreen(
           frame_->GetWidget()->GetNativeView()->parent(),
           snap_sizer_->target_bounds());
-    case SNAP_MAXIMIZE:
+    case workspace::SNAP_MAXIMIZE:
       return ScreenAsh::ConvertRectToScreen(
           window->parent(),
           ScreenAsh::GetMaximizedWindowBoundsInParent(window));
-    case SNAP_MINIMIZE: {
+    case workspace::SNAP_MINIMIZE: {
       Launcher* launcher = Shell::GetInstance()->launcher();
       gfx::Rect item_rect(launcher->GetScreenBoundsOfItemIconForWindow(window));
       if (!item_rect.IsEmpty()) {
         // PhantomWindowController insets slightly, outset it so the phantom
         // doesn't appear inset.
         item_rect.Inset(-8, -8);
         return item_rect;
       }
       return launcher->widget()->GetWindowBoundsInScreen();
     }
-    case SNAP_RESTORE: {
+    case workspace::SNAP_RESTORE: {
       const gfx::Rect* restore = GetRestoreBoundsInScreen(window);
       return restore ?
           *restore : frame_->GetWidget()->GetWindowBoundsInScreen();
     }
-    case SNAP_NONE:
+    case workspace::SNAP_NONE:
       NOTREACHED();
   }
   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::Snap() {
   switch (snap_type_) {
-    case SNAP_LEFT:
-    case SNAP_RIGHT:
+    case workspace::SNAP_LEFT:
+    case workspace::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:
+    case workspace::SNAP_MAXIMIZE:
       frame_->GetWidget()->Maximize();
       break;
-    case SNAP_MINIMIZE:
+    case workspace::SNAP_MINIMIZE:
       frame_->GetWidget()->Minimize();
       break;
-    case SNAP_RESTORE:
+    case workspace::SNAP_RESTORE:
       frame_->GetWidget()->Restore();
       break;
-    case SNAP_NONE:
+    case workspace::SNAP_NONE:
       NOTREACHED();
   }
 }
 
 }  // namespace ash