Added restore functionality for maximize full/left/right

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"
@@ skipping 194 matching lines @@
 void FrameMaximizeButton::OnMouseEntered(const ui::MouseEvent& event) {
   ImageButton::OnMouseEntered(event);
   if (!maximizer_.get()) {
     DCHECK(GetWidget());
     if (!window_) {
       window_ = frame_->GetWidget()->GetNativeWindow();
       window_->AddObserver(this);
     }
     maximizer_.reset(new MaximizeBubbleController(
         this,
-        frame_->GetWidget()->IsMaximized(),
+        GetMaximizeType(),
         bubble_appearance_delay_ms_));
   }
 }
 
 void FrameMaximizeButton::OnMouseExited(const ui::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()) {
     if (maximizer_->GetBubbleWindow()) {
@@ skipping 65 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);
 }
 
+void FrameMaximizeButton::ToggleMaximize() {
+  if (frame_->GetWidget()->IsMaximized())
+    frame_->GetWidget()->Restore();
+  else
+    Maximize();
+}
+
 void FrameMaximizeButton::ProcessStartEvent(const ui::LocatedEvent& event) {
   DCHECK(is_snap_enabled_);
   // Prepare the help menu.
   if (!maximizer_.get()) {
     maximizer_.reset(new MaximizeBubbleController(
         this,
-        frame_->GetWidget()->IsMaximized(),
+        GetMaximizeType(),
         bubble_appearance_delay_ms_));
   } 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;
@@ skipping 107 matching lines @@
   }
   if (maximizer_.get()) {
     phantom_window_->set_phantom_below_window(maximizer_->GetBubbleWindow());
     maximizer_->SetSnapType(snap_type_);
   }
   phantom_window_->Show(ScreenBoundsForType(snap_type_, *snap_sizer_.get()));
 }
 
 SnapType FrameMaximizeButton::SnapTypeForLocation(
     const gfx::Point& location) const {
+  MaximizeType maximize_type = GetMaximizeType();
   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 maximize_type != MAXIMIZE_FULL ? SNAP_MAXIMIZE : SNAP_RESTORE;
   else if (delta_x < 0 && delta_y > delta_x && delta_y < -delta_x)
-    return SNAP_LEFT;
+    return maximize_type == MAXIMIZE_LEFT ? SNAP_RESTORE : SNAP_LEFT;
   else if (delta_x > 0 && delta_y > -delta_x && delta_y < delta_x)
-    return SNAP_RIGHT;
+    return maximize_type == MAXIMIZE_RIGHT ? SNAP_RESTORE : SNAP_RIGHT;
   else if (delta_y > 0)
     return SNAP_MINIMIZE;
-  return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE;
+  return maximize_type != MAXIMIZE_FULL ? SNAP_MAXIMIZE : SNAP_RESTORE;
 }
 
 gfx::Rect FrameMaximizeButton::ScreenBoundsForType(
     SnapType type,
     const SnapSizer& snap_sizer) const {
   aura::Window* window = frame_->GetWidget()->GetNativeWindow();
   switch (type) {
     case SNAP_LEFT:
     case SNAP_RIGHT:
       return ScreenAsh::ConvertRectToScreen(
@@ skipping 26 matching lines @@
 }
 
 gfx::Point FrameMaximizeButton::LocationForSnapSizer(
     const gfx::Point& location) const {
   gfx::Point result(location);
   views::View::ConvertPointToScreen(this, &result);
   return result;
 }
 
 void FrameMaximizeButton::Snap(const SnapSizer& snap_sizer) {
+  views::Widget* widget = frame_->GetWidget();
   switch (snap_type_) {
     case SNAP_LEFT:
-    case SNAP_RIGHT:
-      if (frame_->GetWidget()->IsMaximized()) {
+    case SNAP_RIGHT: {
+        // Get the window coordinates on the screen for restore purposes.
+        gfx::Rect restore = frame_->GetWidget()->GetNativeWindow()->bounds();
+        if (frame_->GetWidget()->IsMaximized()) {
+          // If it was maximized we need to recover the old restore set.
+          restore = *ash::GetRestoreBoundsInScreen(
+              frame_->GetWidget()->GetNativeWindow());
+          // Set the restore size we want to restore to.
+          ash::SetRestoreBoundsInScreen(frame_->GetWidget()->GetNativeWindow(),
+                                        ScreenBoundsForType(snap_type_,
+                                                            snap_sizer));
+          frame_->GetWidget()->Restore();
+        } else {
+          frame_->GetWidget()->SetBounds(ScreenBoundsForType(snap_type_,
+                                                             snap_sizer));
+        }
+        // Remember the widow's bounds for restoration.
         ash::SetRestoreBoundsInScreen(frame_->GetWidget()->GetNativeWindow(),
-                                      ScreenBoundsForType(snap_type_,
-                                                          snap_sizer));
-        frame_->GetWidget()->Restore();
-      } else {
-        frame_->GetWidget()->SetBounds(ScreenBoundsForType(snap_type_,
-                                                           snap_sizer));
+            restore);
       }
       break;
     case SNAP_MAXIMIZE:
-      frame_->GetWidget()->Maximize();
+      Maximize();
       break;
     case SNAP_MINIMIZE:
-      frame_->GetWidget()->Minimize();
+      widget->Minimize();
       break;
     case SNAP_RESTORE:
-      frame_->GetWidget()->Restore();
+      widget->Restore();
       break;
     case SNAP_NONE:
       NOTREACHED();
   }
 }
 
+MaximizeType FrameMaximizeButton::GetMaximizeType() const {
+  // When there are no restore bounds, we are in normal mode.
+  if (!ash::GetRestoreBoundsInScreen(
+              frame_->GetWidget()->GetNativeWindow()))
+    return MAXIMIZE_NONE;
+  // The normal maximized test can be used.
+  if (frame_->GetWidget()->IsMaximized())
+    return MAXIMIZE_FULL;
+  // For Left/right maximize we need to check the dimensions.
+  gfx::Rect bounds = frame_->GetWidget()->GetNativeWindow()->bounds();
+  gfx::Rect screen = gfx::Screen::GetDisplayMatching(bounds).work_area();
+  // We have to be in a maximize mode at this point.
+  DCHECK(!bounds.y());

[sky, 2012/08/27 22:18:16]

Why does the x/y need to be 0 here? Might it differ in multi-mon?

[Mr4D (OOO till 08-26), 2012/08/28 01:30:25]

Very good point! Changed!

+  DCHECK(bounds.height() >= screen.height());
+  if (!bounds.x())
+    return MAXIMIZE_LEFT;
+  if (bounds.right() == screen.right())
+    return MAXIMIZE_RIGHT;
+  NOTREACHED();
+  return MAXIMIZE_NONE;
+}
+
+void FrameMaximizeButton::Maximize() {
+  views::Widget* widget = frame_->GetWidget();
+  MaximizeType maximize_type = GetMaximizeType();
+  if (maximize_type == MAXIMIZE_LEFT || maximize_type == MAXIMIZE_RIGHT) {
+    aura::Window* window = widget->GetNativeWindow();
+    gfx::Rect restore = *ash::GetRestoreBoundsInScreen(window);
+    widget->Maximize();
+    ash::SetRestoreBoundsInScreen(window, restore);
+  } else {
+    widget->Maximize();
+  }
+  // Note: |This| might be destroyed at this time.
+}
+
 }  // namespace ash