Ignoring alignment when it pushes a window out of the screen

chrome/browser/ui/views/ash/window_positioner.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 "chrome/browser/ui/views/ash/window_positioner.h"
 
 #include "ash/shell.h"
 #include "ash/wm/window_cycle_controller.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/window.h"
@@ skipping 37 matching lines @@
   aura::Window* window = ash::wm::GetActiveWindow();
   const gfx::Rect work_area = window && window->IsVisible() ?
       gfx::Screen::GetMonitorWorkAreaNearestWindow(window) :
       gfx::Screen::GetPrimaryMonitorWorkArea();
   // Only try to reposition the popup when it is not spanning the entire
   // screen.
   if ((old_pos.width() + popup_position_offset_from_screen_corner_x >=
       work_area.width()) ||
       (old_pos.height() + popup_position_offset_from_screen_corner_y >=
        work_area.height()))
-    return old_pos;
-  const gfx::Rect result = SmartPopupPosition(old_pos, work_area);
+    return AlignPopupPosition(old_pos, work_area, grid);
+  const gfx::Rect result = SmartPopupPosition(old_pos, work_area, grid);
   if (!result.IsEmpty())
-    return result;
+    return AlignPopupPosition(result, work_area, grid);
   return NormalPopupPosition(old_pos, work_area);
 }
 
 gfx::Rect WindowPositioner::NormalPopupPosition(
     const gfx::Rect& old_pos,
     const gfx::Rect& work_area) {
   int w = old_pos.width();
   int h = old_pos.height();
   // Note: The 'last_popup_position' is checked and kept relative to the
   // screen size. The offsetting will be done in the last step when the
@@ skipping 18 matching lines @@
   int y = last_popup_position_y_;
   if (!reset) {
     last_popup_position_x_ += pop_position_offset_increment_x;
     last_popup_position_y_ += pop_position_offset_increment_y;
   }
   return gfx::Rect(x + work_area.x(), y + work_area.y(), w, h);
 }
 
 gfx::Rect WindowPositioner::SmartPopupPosition(
     const gfx::Rect& old_pos,
-    const gfx::Rect& work_area) {
+    const gfx::Rect& work_area,
+    int grid) {
   const std::vector<aura::Window*> windows =
       ash::WindowCycleController::BuildWindowList();
 
   std::vector<const gfx::Rect*> regions;
   // Process the window list and check if we can bail immediately.
   for (size_t i = 0; i < windows.size(); i++) {
     // We only include opaque and visible windows.
     if (windows[i] && windows[i]->IsVisible() && windows[i]->layer() &&
         (!windows[i]->transparent() ||
          windows[i]->layer()->GetTargetOpacity() == 1.0)) {
@@ skipping 32 matching lines @@
     }
     // Note: The passing (x,y,w,h) window is always relative to the work area's
     // origin.
     for (; x_increment > 0 ? (x < x_end) : (x > x_end); x += x_increment) {
       int y = 0;
       while (y + h <= work_area.height()) {
         size_t i;
         for (i = 0; i < regions.size(); i++) {
           if (regions[i]->Intersects(gfx::Rect(x + work_area.x(),
                                                y + work_area.y(), w, h))) {
-            y = regions[i]->y() + regions[i]->height() - work_area.y();
+            y = regions[i]->bottom() - work_area.y();
+            // Align to the next 'full' grid step.
+            if (grid > 1) {
+              // Align to the grid.
+              y += (grid - (y + grid - 1) % grid) % grid;

[sky, 2012/04/13 19:44:02]

I don't understand this code. I'm sure I missing something, but if you want to
align to the grid how come this isn't:

y = y / grid * grid
?

[Mr4D (OOO till 08-26), 2012/04/13 20:47:39]

y / grid * grid: Certainly not. The compiler (windows at least) will optimize
that likely away (seen that in the past). But furthermore we want to gravitate
to the next line. So I might use something else here..

[sky, 2012/04/13 21:42:03]

That sounds like a compiler bug, we have code like that else where.
If you want to gravitate, then use WindowResizer::AlignToGrid.

[Mr4D (OOO till 08-26), 2012/04/13 22:33:48]

It is not exactly a compiler bug - it is a behavior. I am not even sure if the
arithmetic has to be performed within the equation in pure integer - or if it
might even use 'higher precision' and floats. I know for sure that the windows
compilers in the past were doing it that way.


"Gravitate" was probably the wrong word - what I meant is: Take the next aligned
and uncovered position. This is doing exactly what we want.

+            }
             break;
           }
         }
         if (i >= regions.size())
           return gfx::Rect(x + work_area.x(), y + work_area.y(), w, h);
       }
     }
   }
   return gfx::Rect(0, 0, 0, 0);
 }
+
+gfx::Rect WindowPositioner::AlignPopupPosition(
+    const gfx::Rect& pos,
+    const gfx::Rect& work_space,
+    int grid) {
+  if (grid <= 1)
+    return pos;
+
+  int x = pos.x() - (pos.x() - work_space.x()) % grid;
+  int y = pos.y() - (pos.y() - work_space.y()) % grid;
+  int w = pos.width();
+  int h = pos.height();
+
+  // If the alignment was pushing the window out of the screen, we ignore the
+  // alignment for that call.
+  if (abs(pos.right() - work_space.right()) < grid) {

[sky, 2012/04/13 19:44:02]

nit: no {} here and 188

[Mr4D (OOO till 08-26), 2012/04/13 20:47:39]

Done.

+    x = work_space.right() - w;
+  }
+  if (abs(pos.bottom() - work_space.bottom()) < grid) {
+    y = work_space.bottom() - h;
+  }
+  return gfx::Rect(x, y, w, h);
+}