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/window_maximize.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) {
+      snap_type_(SNAP_NONE),
+      maximizer_(NULL) {
   // 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() {
 }
 
 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())
+    maximizer_.reset(new MaximizeBubble(this,
+        frame_->GetWidget()->IsMaximized()));
 }
 
 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();
+    if (!maximizer_->GetMenuWindow()->bounds().Contains(screen_location))
+      maximizer_.reset(NULL);
+  }
 }
 
 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(NULL);
 }
 
 void FrameMaximizeButton::OnMouseCaptureLost() {
   Cancel();
   ImageButton::OnMouseCaptureLost();
+  if (!is_snap_enabled_)
+    maximizer_.reset(NULL);
 }
 
 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 20 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 / helo menu.
+  if (!maximizer_.get()) {
+    maximizer_.reset(new MaximizeBubble(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);
 }
 
 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());
+
+  // Update the halo menu.
+  if (maximizer_.get() && maximizer_->IsRadialMenu()) {
+    gfx::Point pt = event.location();
+    views::View::ConvertPointToScreen(this, &pt);
+    FrameMaximizeButton::SnapType type;
+    maximizer_->SnapTypeForLocation(pt, type);
+  }
 }
 
 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.
+  gfx::Point screen_location = gfx::Screen::GetCursorScreenPoint();
+  if (!GetBoundsInScreen().Contains(screen_location))
+    maximizer_.reset();
+
   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() {
   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;
+      snap_sizer_.reset();
+      SchedulePaint();
+      phantom_window_.reset();
+      return;
+    default:
+      // We should not come here.
+      DCHECK(false);
+      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())
+    maximizer_->SetMenuState(snap_type_);
 }
 
 FrameMaximizeButton::SnapType FrameMaximizeButton::SnapTypeForLocation(
     const gfx::Point& location) const {
+  if (maximizer_.get() && maximizer_->IsRadialMenu()) {
+    FrameMaximizeButton::SnapType code;
+    gfx::Point pt = location;
+    views::View::ConvertPointToScreen(this, &pt);
+    maximizer_->SnapTypeForLocation(pt, code);
+    if (code != SNAP_NONE)
+      return code;
+    return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE;
+  }
   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;
   else if (delta_x > 0 && delta_y > -delta_x && delta_y < delta_x)
     return SNAP_RIGHT;
   else if (delta_y > 0)
     return SNAP_MINIMIZE;
@@ skipping 34 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::SnapButtonClicked(SnapType snap_type) {
+  snap_type_ = snap_type;
+  Snap();
+  // Remove any pending snap previews.
+  SnapButtonHovered(SNAP_NONE);
+}
+
 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() {
+  if (maximizer_.get())
+    maximizer_.reset();
+}
+
 }  // namespace ash