Only support left/right maximizing at 50% width when the --ash-enable-alternate-caption-button

ash/wm/window_util.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/window_util.h"
 
 #include <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/root_window_controller.h"
+#include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/activation_controller.h"
+#include "ash/wm/property_util.h"
 #include "ash/wm/window_properties.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/corewm/window_util.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace wm {
+namespace {
+
+// The percent of the screen's width that a snapped window takes up.
+const int kSnappedWindowScreenWidthPercent = 50;
+
+}  // namespace
 
 // TODO(beng): replace many of these functions with the corewm versions.
 void ActivateWindow(aura::Window* window) {
   views::corewm::ActivateWindow(window);
 }
 
 void DeactivateWindow(aura::Window* window) {
   views::corewm::DeactivateWindow(window);
 }
 
@@ skipping 31 matching lines @@
   return true;
 }
 
 bool CanResizeWindow(const aura::Window* window) {
   return window->GetProperty(aura::client::kCanResizeKey);
 }
 
 bool CanSnapWindow(aura::Window* window) {
   if (!CanResizeWindow(window))
     return false;
-  // If a window has a maximum size defined, snapping may make it too big.
-  return window->delegate() ? window->delegate()->GetMaximumSize().IsEmpty() :
-                              true;
+
+  if (window->delegate()) {
+    // The size of a snapped window is not affected by the edge it is snapped
+    // to.
+    gfx::Size snapped_size =
+        GetSnappedWindowBoundsInParent(window, SNAP_LEFT_EDGE).size();
+
+    gfx::Size minimum_size = window->delegate()->GetMinimumSize();
+    if (minimum_size.width() > snapped_size.width())

[Mr4D (OOO till 08-26), 2013/08/29 01:03:15]

Hmm. Does this mean that if you have a window which cannot be half screen size
it cannot L/R maximize?

That is not good. Especially because we said one that Browser windows should
have a generous minimum size (thinking about all our defaults of that windows
come up maximized if the screen res is smaller then 1440 width and what not).

As such: If we have this limitation build in there will be only a few things
left which can be "maximized that way". Did Kuscher agree on that? There is no
harm of having maximized windows be overlap if they need to be bigger...

+      return false;
+    gfx::Size maximum_size = window->delegate()->GetMaximumSize();
+    if (!maximum_size.IsEmpty() &&
+        (maximum_size.width() < snapped_size.width() ||
+         maximum_size.height() < snapped_size.height())) {
+      return false;
+    }
+  }
+  return true;
 }
 
 bool IsWindowNormal(const aura::Window* window) {
   return IsWindowStateNormal(window->GetProperty(aura::client::kShowStateKey));
 }
 
 bool IsWindowStateNormal(ui::WindowShowState state) {
   return state == ui::SHOW_STATE_NORMAL || state == ui::SHOW_STATE_DEFAULT;
 }
 
@@ skipping 18 matching lines @@
 
 void MinimizeWindow(aura::Window* window) {
   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
 }
 
 void RestoreWindow(aura::Window* window) {
   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 }
 
 void ToggleMaximizedWindow(aura::Window* window) {
-  if (ash::wm::IsWindowMaximized(window))
-    ash::wm::RestoreWindow(window);
-  else if (ash::wm::CanMaximizeWindow(window))
-    ash::wm::MaximizeWindow(window);
+  if (IsWindowMaximized(window))
+    RestoreWindow(window);
+  else if (CanMaximizeWindow(window))
+    MaximizeWindow(window);
+}
+
+gfx::Rect GetSnappedWindowBoundsInParent(aura::Window* window, SnapEdge edge) {
+  gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window));
+  int width = work_area.width() * kSnappedWindowScreenWidthPercent / 100;
+  int x = (edge == SNAP_LEFT_EDGE) ? work_area.x() : work_area.right() - width;
+
+  return gfx::Rect(x, work_area.y(), width, work_area.height());
+}
+
+void SnapWindowToEdge(aura::Window* window, SnapEdge edge) {
+  gfx::Rect bounds(GetSnappedWindowBoundsInParent(window, edge));
+
+  if (IsWindowFullscreen(window) || IsWindowMaximized(window)) {
+    // Before we can set the bounds we need to restore the window.
+    // Restoring the window will set the window to its restored bounds.
+    // To avoid an unnecessary bounds changes (which may have side effects)
+    // we set the restore bounds to the bounds we want, restore the window,
+    // then reset the restore bounds. This way no unnecessary bounds
+    // changes occurs and the original restore bounds is remembered.
+    gfx::Rect restore = *GetRestoreBoundsInScreen(window);
+    SetRestoreBoundsInParent(window, bounds);
+    RestoreWindow(window);
+    SetRestoreBoundsInScreen(window, restore);
+  } else {
+    window->SetBounds(bounds);
+  }
 }
 
 void CenterWindow(aura::Window* window) {
   const gfx::Display display =
       Shell::GetScreen()->GetDisplayNearestWindow(window);
   gfx::Rect center = display.work_area();
   center.ClampToCenteredSize(window->bounds().size());
   window->SetBoundsInScreen(center, display);
 }
 
@@ skipping 67 matching lines @@
     return false;
   aura::Window* window_container =
       ash::Shell::GetContainer(target_root, window->parent()->id());
   // Move the window to the target launcher.
   window_container->AddChild(window);
   return true;
 }
 
 }  // namespace wm
 }  // namespace ash