Merge lp:~smspillaz/compiz-core/fix_898949 into lp:compiz-core/0.9.5

[Sam Spilsbury]

Refactored and cleaned up a lot of the place plugin's screen size change handling code.

 * Moved the screen size change handling code into its own worker class which PlaceWindow derives from which automatically handles the save/restore of geometry on screen size changes.
 * Moved screen size change handling code into its own nameespace
 * Removed the two-pass semantics from the function - strut window collection is always done separately and we either wait until all of the external application which provide strut windows (eg, docks, panels) update their struts, or if they don't do it, time out after about 4 seconds and move windows on-screen anyways.
 * Position save now happens at the same time as the geometry is updated.
 * Added testcases for screen size change handling, in test-place-screen-size-change

Next pipe: lp:~smspillaz/compiz-core/fix_899557

[Sam Spilsbury (smspillaz)]

Refactored and cleaned up a lot of the place plugin's screen size change handling code.

 * Moved the screen size change handling code into its own worker class which PlaceWindow derives from which automatically handles the save/restore of geometry on screen size changes.
 * Moved screen size change handling code into its own nameespace
 * Removed the two-pass semantics from the function - strut window collection is always done separately and we either wait until all of the external application which provide strut windows (eg, docks, panels) update their struts, or if they don't do it, time out after about 4 seconds and move windows on-screen anyways.
 * Position save now happens at the same time as the geometry is updated.
 * Added testcases for screen size change handling, in test-place-screen-size-change

[Thomi Richards (thomir-deactivatedaccount)]

Diff lines 437, 443, maybe 449, and 455: can these methods be marked as 'const'? At a glance it looks like they should be.

ditto diff lines 620 - 623.

Diff line 690 - 711 - Don't leave commented out code in the merge. If it's for future features, move it into a separate Bazaar branch. Future developers will look at this and think "I wonder why that's commented out?".

Ditto lines 815 - 874.

Diff lines 940, 941 & 942 - can these be made const?

Diff lines 1177 - 1187 - did you mean to leave this in?

Diff lines 1803, 1808, 1870, 1875 - Is it possible for 'base' to be 0 here? If so, you've got a problem. It may pay to be a bit more defensive and do something more sensible than crash if it ever happens.

ln 2094 - WHy the cast?

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

> Diff lines 437, 443, maybe 449, and 455: can these methods be marked as
> 'const'? At a glance it looks like they should be.
>
> ditto diff lines 620 - 623.

Ack.

>
> Diff line 690 - 711 - Don't leave commented out code in the merge. If it's for
> future features, move it into a separate Bazaar branch. Future developers will
> look at this and think "I wonder why that's commented out?".
>
> Ditto lines 815 - 874.
>
> Diff lines 940, 941 & 942 - can these be made const?
>
> Diff lines 1177 - 1187 - did you mean to leave this in?
>

Ack.

> Diff lines 1803, 1808, 1870, 1875 - Is it possible for 'base' to be 0 here? If
> so, you've got a problem. It may pay to be a bit more defensive and do
> something more sensible than crash if it ever happens.
>

Done, although I think in those codepaths only yinc and xinc were being passed as the base value and they are already constrained to start from 1. However, it doesn't make sense for an object to have a width or height of zero anyways, and we shouldn't allow windows to specify that since trying to resize to that will result in a BadValue error on the server and will generally wreak havoc on the system because it thinks the window is smaller than it is. So I've constrained to start from 1 on all the other width/height values too.

> ln 2094 - WHy the cast?

[Thomas Voß (thomas-voss)]

In addition to Thomi's remarks:

  * In compiz::window::Extents:

    * Get rid of the public identifier. Extents is a struct and thus, default visibility is public.

    * You can leave out the custom operator== and operator!= and rely on the compiler generated ones.
      Nevertheless, you should leave a comment in there.

    * Defining a default c'tor assigning default values to the members is missing.

review: Needs Fixing

Unmerged revisions

2982. By Sam Spilsbury on 2012-01-11

Merge

2981. By Sam Spilsbury on 2012-01-11

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2980. By Sam Spilsbury on 2012-01-11

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2979. By Sam Spilsbury on 2012-01-11

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2978. By Sam Spilsbury on 2012-01-11

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2977. By Sam Spilsbury on 2012-01-10

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2976. By Sam Spilsbury on 2012-01-09

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2975. By Sam Spilsbury on 2012-01-09

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2974. By Sam Spilsbury on 2012-01-09

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

2973. By Sam Spilsbury on 2012-01-09

Merged compiz-core.fix_898469 into compiz-core.fix_898949.

=== modified file 'include/core/screen.h'
--- include/core/screen.h	2012-01-13 13:20:02 +0000
+++ include/core/screen.h	2012-01-13 13:20:03 +0000
@@ -324,7 +324,7 @@
 
 	int outputDeviceForGeometry (const compiz::window::Geometry& gm);
 
-	CompPoint vp ();
+	const CompPoint & vp () const;
 
 	CompSize vpSize ();
 

=== modified file 'include/core/size.h'
--- include/core/size.h	2010-03-24 09:37:19 +0000
+++ include/core/size.h	2012-01-13 13:20:03 +0000
@@ -50,6 +50,8 @@
 	typedef std::list<CompSize> list;
 	typedef std::list<CompSize *> ptrList;
 
+	bool operator== (const CompSize &other) const;
+	bool operator!= (const CompSize &other) const;
     private:
 	int mWidth, mHeight;
 };

=== modified file 'include/core/window.h'
--- include/core/window.h	2012-01-13 13:20:02 +0000
+++ include/core/window.h	2012-01-13 13:20:03 +0000
@@ -44,6 +44,7 @@
 #include <core/windowgeometry.h>
 #include <core/windowgeometrysaver.h>
 #include <core/windowextents.h>
+#include <core/windowconstrainment.h>
 
 #include <core/wrapsystem.h>
 
@@ -235,9 +236,17 @@
  */
 static const unsigned int ConstrainPositionVirtualScreen (1 << 2);
 
-
-}
-}
+namespace constrainment
+{
+
+CompSize constrainToHints (CompWindow       *w,
+			   const CompSize   &size);
+}
+
+}
+}
+
+
 /**
  * Wrappable core window functions. Derive from this class
  * and overload these functions in order to have your function called

=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ plugins/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -18,6 +18,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/geometry/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/geometry-saver/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/extents/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/../src/window/constrainment/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../src/point/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../src/rect/include
 )

=== modified file 'plugins/decor/src/decor.cpp'
--- plugins/decor/src/decor.cpp	2012-01-13 13:20:02 +0000
+++ plugins/decor/src/decor.cpp	2012-01-13 13:20:03 +0000
@@ -1472,7 +1472,7 @@
     if (old)
     {
 	oldShift = compiz::window::extents::shift (window->border (),
-					   window->sizeHints ().win_gravity);
+						   window->sizeHints ().win_gravity);
 
 	WindowDecoration::destroy (wd);
 
@@ -1504,7 +1504,7 @@
 					   &wd->decor->input);
 
 	movement = compiz::window::extents::shift (window->border (),
-					   window->sizeHints ().win_gravity) - oldShift;
+						   window->sizeHints ().win_gravity) - oldShift;
 
 	/* Update the input and output frame */
 	if (decorate)

=== modified file 'plugins/place/CMakeLists.txt'
--- plugins/place/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ plugins/place/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -5,7 +5,8 @@
 # FIXME: Remove once MODULES support lands
 
 add_subdirectory (src/constrain-to-workarea)
-add_subdirectory (tests)
+add_subdirectory (src/screen-size-change)
 
-include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/constrain-to-workarea/include/)
-compiz_plugin (place LIBRARIES compiz_place_constrain_to_workarea)
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/constrain-to-workarea/include/
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/screen-size-change/include/))
+compiz_plugin (place LIBRARIES compiz_place_constrain_to_workarea compiz_place_screen_size_change)

=== modified file 'plugins/place/src/constrain-to-workarea/CMakeLists.txt'
--- plugins/place/src/constrain-to-workarea/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ plugins/place/src/constrain-to-workarea/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -51,6 +51,7 @@
 SET_TARGET_PROPERTIES(
   compiz_place_constrain_to_workarea PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'plugins/place/src/constrain-to-workarea/tests/constrain-to-workarea/src/CMakeLists.txt'
--- plugins/place/src/constrain-to-workarea/tests/constrain-to-workarea/src/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ plugins/place/src/constrain-to-workarea/tests/constrain-to-workarea/src/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -6,19 +6,24 @@
 		     ${compiz_BINARY_DIR}/generated
 		     ${compiz_SOURCE_DIR}/src
 		     ${compiz_SOURCE_DIR}/plugins/place/src
+		     ${compiz_SOURCE_DIR}/src/window/geometry/include/
+		     ${compiz_SOURCE_DIR}/src/window/geometry-saver/include/
+		     ${compiz_SOURCE_DIR}/src/window/extents/include/
+		     ${compiz_SOURCE_DIR}/src/point/include/
+		     ${compiz_SOURCE_DIR}/src/rect/include/
 		     ${COMPIZ_PLACE_TEST_BASE_DIR})
 
 add_executable (test-place-clamp-to-workarea
 		test-place-constrain-to-workarea.cpp
 		../test-place.cpp 
 		${compiz_SOURCE_DIR}/plugins/place/src/constrain-to-workarea.cpp
-		${compiz_SOURCE_DIR}/src/windowextents.cpp
-		${compiz_SOURCE_DIR}/src/windowgeometry.cpp
-		${compiz_SOURCE_DIR}/src/rect.cpp
-		${compiz_SOURCE_DIR}/src/point.cpp
 		${compiz_SOURCE_DIR}/src/size.cpp)
 
 target_link_libraries (test-place-clamp-to-workarea
+		       compiz_window_geometry
+		       compiz_window_extents
+		       compiz_point
+		       compiz_rect
 		       ${COMPIZ_TEST_PLACE_LIBRARIES})
 
 add_test (test-place-clamp-to-workarea

=== modified file 'plugins/place/src/constrain-to-workarea/tests/constrain-to-workarea/src/test-place-constrain-to-workarea.cpp'
--- plugins/place/src/constrain-to-workarea/tests/constrain-to-workarea/src/test-place-constrain-to-workarea.cpp	2012-01-13 13:20:02 +0000
+++ plugins/place/src/constrain-to-workarea/tests/constrain-to-workarea/src/test-place-constrain-to-workarea.cpp	2012-01-13 13:20:03 +0000
@@ -60,4 +60,56 @@
     compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
 
     EXPECT_EQ (g, compiz::window::Geometry (100, 100, 200, 200, 0));
+
+    /* Larger than workArea */
+    g = compiz::window::Geometry (50, 50, 950, 1950, 0);
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
+
+    EXPECT_EQ (g, compiz::window::Geometry (50, 50, 900, 1900, 0));
+
+    /* Outside top left */
+    g = compiz::window::Geometry (0, 0, 900, 1900, 0);
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
+
+    EXPECT_EQ (g, compiz::window::Geometry (50, 50, 900, 1900, 0));
+
+    /* Outside top right */
+    g = compiz::window::Geometry (100, 0, 900, 1900, 0);
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
+
+    EXPECT_EQ (g, compiz::window::Geometry (50, 50, 900, 1900, 0));
+
+    /* Outside bottom left */
+    g = compiz::window::Geometry (0, 100, 900, 1900, 0);
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
+
+    EXPECT_EQ (g, compiz::window::Geometry (50, 50, 900, 1900, 0));
+
+    /* Outside bottom right */
+    g = compiz::window::Geometry (100, 100, 900, 1900, 0);
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
+
+    EXPECT_EQ (g, compiz::window::Geometry (50, 50, 900, 1900, 0));
+
+    /* For the size only case, we should not
+     * change the position of the window if
+     * the size does not change */
+    g = compiz::window::Geometry (0, 0, 900, 1900, 0);
+    flags = compiz::place::clampGeometrySizeOnly;
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
+
+    EXPECT_EQ (g, compiz::window::Geometry (0, 0, 900, 1900, 0));
+
+    g = compiz::window::Geometry (0, 0, 1000, 2000, 0);
+    flags = compiz::place::clampGeometrySizeOnly;
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, extents, flags, screensize);
+
+    EXPECT_EQ (g, compiz::window::Geometry (50, 50, 900, 1900, 0));
 }

=== modified file 'plugins/place/src/constrain-to-workarea/tests/test-constrain-to-workarea.h'
--- plugins/place/src/constrain-to-workarea/tests/test-constrain-to-workarea.h	2012-01-13 13:20:02 +0000
+++ plugins/place/src/constrain-to-workarea/tests/test-constrain-to-workarea.h	2012-01-13 13:20:03 +0000
@@ -29,6 +29,7 @@
 #include <gtest/gtest.h>
 #include <core/rect.h>
 #include <core/windowgeometry.h>
+#include <core/windowgeometrysaver.h>
 #include <core/windowextents.h>
 #include <core/size.h>
 #include <core/point.h>

=== modified file 'plugins/place/src/place.cpp'
--- plugins/place/src/place.cpp	2012-01-13 13:20:02 +0000
+++ plugins/place/src/place.cpp	2012-01-13 13:20:03 +0000
@@ -27,7 +27,7 @@
 PlaceScreen::PlaceScreen (CompScreen *screen) :
     PluginClassHandler<PlaceScreen, CompScreen> (screen),
     mPrevSize (screen->width (), screen->height ()),
-    mStrutWindowCount (0),
+    mStrutWindows (0),
     fullPlacementAtom (XInternAtom (screen->dpy (),
     				    "_NET_WM_FULL_PLACEMENT", 0))
 {
@@ -45,25 +45,29 @@
     screen->updateSupportedWmHints ();
 }
 
-/* FIXME: This should really be in core */
+CompWindowList
+compiz::place::collectStrutWindows (const CompWindowList &all)
+{
+    CompWindowList l;
+
+    foreach (CompWindow *w, all)
+    {
+	if (!w->managed () ||
+	    w->overrideRedirect ())
+	    continue;
+
+	if (w->struts ())
+	    l.push_back (w);
+    }
+
+    return l;
+}
+
 void
 PlaceScreen::doHandleScreenSizeChange (bool firstPass,
 				       int  newWidth,
 				       int  newHeight)
 {
-    int            vpX, vpY, shiftX, shiftY;
-    CompRect       extents;
-    compiz::window::Geometry g;
-    CompRect       vpRelRect, winRect, workArea;
-    int		   pivotX, pivotY;
-    int		   curVpOffsetX = screen->vp ().x () * newWidth;
-    int		   curVpOffsetY = screen->vp ().y () * newHeight;
-
-    if (firstPass)
-	mStrutWindowCount = 0;
-    else if (mResChangeFallbackHandle.active ())
-	mResChangeFallbackHandle.stop ();
-
     foreach (CompWindow *w, screen->windows ())
     {
 	if (!w->managed ())
@@ -73,10 +77,6 @@
 
 	if (firstPass)
 	{
-	    /* count the windows that have struts */
-	    if (w->struts ())
-		mStrutWindowCount++;
-
 	    /* for maximized/fullscreen windows, keep window coords before
 	     * screen resize, as they are sometimes automaticall changed
 	     * before the 2nd pass */
@@ -95,175 +95,55 @@
 	    continue;
 	}
 
-	/* Also in the first pass, we save the rectangle of those windows that
-	 * don't already have a saved one. So, skip those tat do. */
-
-	if (firstPass && pw->mSavedOriginal)
-	    continue;
-
-	winRect = ((CompRect) w->serverGeometry ());
-
-	pivotX = winRect.x ();
-	pivotY = winRect.y ();
-
-	/* FIXME: used the saved geometry for windows that are maximized
-	 * or fullscreen to determine which screen or viewport they actually
-	 * lie on */
-	if (w->type () & CompWindowTypeFullscreenMask ||
-	    (w->state () & (CompWindowStateMaximizedVertMask |
-	    		    CompWindowStateMaximizedHorzMask)))
-	{
-	    pivotX = pw->mPrevServer.x ();
-	    pivotY = pw->mPrevServer.y ();
-	}
-
-	/* calculate target vp x, y index for window's pivot point */
-	vpX = pivotX / mPrevSize.width ();
-	if (pivotX < 0)
-	    vpX -= 1;
-	vpY = pivotY / mPrevSize.height ();
-	if (pivotY < 0)
-	    vpY -= 1;
-
-	/* if window's target vp is to the left of the leftmost viewport on that
-	   row, assign its target vp column as 0 (-s->x rel. to current vp) */
-	if (screen->vp ().x () + vpX < 0)
-	    vpX = -screen->vp ().x ();
-
-	/* if window's target vp is above the topmost viewport on that column,
-	   assign its target vp row as 0 (-s->y rel. to current vp) */
-	if (screen->vp ().y () + vpY < 0)
-	    vpY = -screen->vp ().y ();
-
-	if (pw->mSavedOriginal)
-	{
-	    /* set position/size to saved original rectangle */
-	    vpRelRect = pw->mOrigVpRelRect;
-
-	    g.setPos (CompPoint (pw->mOrigVpRelRect.x () + vpX * newWidth,
-				 pw->mOrigVpRelRect.y () + vpY * newHeight));
-	}
-	else
-	{
-	    /* set position/size to window's current rectangle
-	       (with position relative to target viewport) */
-	    vpRelRect.setX (winRect.x () - vpX * mPrevSize.width ());
-	    vpRelRect.setY (winRect.y () - vpY * mPrevSize.height ());
-	    vpRelRect.setWidth (winRect.width ());
-	    vpRelRect.setHeight (winRect.height ());
-
-	    g.setPos (winRect.pos ());
-
-	    shiftX = vpX * (newWidth - newWidth);
-	    shiftY = vpY * (newWidth - newHeight);
-
-	    /* if coords. relative to viewport are outside new viewport area,
-	       shift window left/up so that it falls inside */
-	    if (vpRelRect.x () >= newWidth)
-		shiftX -= vpRelRect.x () - (newWidth - 1);
-	    if (vpRelRect.y () >= newHeight)
-		shiftY -= vpRelRect.y () - (newHeight - 1);
-
-	    if (shiftX)
-		g.setX (g.x () + shiftX);
-
-	    if (shiftY)
-		g.setY (g.y () + shiftY);
-	}
-
-	g.setWidth (vpRelRect.width ());
-	g.setHeight (vpRelRect.height ());
-
-	/* Handle non-(0,0) current viewport by shifting by curVpOffsetX,Y,
-	   and bring window to (0,0) by shifting by minus its vp offset */
-
-	g.setX (g.x () + curVpOffsetX - (screen->vp ().x () + vpX) * newWidth);
-	g.setY (g.y () + curVpOffsetY - (screen->vp ().y () + vpY) * newHeight);
-
-	unsigned int flags = 0;
-
-	compiz::window::Geometry og (g);
-	CompRect workArea = screen->getWorkareaForOutput (
-				screen->outputDeviceForGeometry (g));
-
-	compiz::place::clampGeometryToWorkArea (g, workArea, w->border (), flags, *screen);
-
-	g.setX (g.x () - curVpOffsetX - (screen->vp ().x () + vpX) * newWidth);
-	g.setY (g.y () - curVpOffsetY - (screen->vp ().y () + vpY) * newHeight);
-
-	if (!pw->mSavedOriginal)
-	{
-	    if (w->serverGeometry ().changeMask (g))
-	    {
-		/* save window geometry (relative to viewport) so that it
-		can be restored later */
-		pw->mSavedOriginal = TRUE;
-		pw->mOrigVpRelRect = vpRelRect;
-	    }
-	}
-	else if (CompRect (pw->mOrigVpRelRect.x () + vpX * newWidth,
-			   pw->mOrigVpRelRect.y () + vpY * newHeight,
-			   pw->mOrigVpRelRect.width (),
-			   pw->mOrigVpRelRect.height ()) == ((CompRect &) g))
-	{
-	    /* if size and position is back to original, clear saved rect */
-	    pw->mSavedOriginal = FALSE;
-	}
-
-	if (firstPass) /* if first pass, don't actually move the window */
-	    continue;
-
-	/* for maximized/fullscreen windows, update saved pos/size XXX */
-	if (w->type () & CompWindowTypeFullscreenMask ||
-	    (w->state () & (CompWindowStateMaximizedVertMask |
-			 CompWindowStateMaximizedHorzMask)))
-	{
-	    /* FIXME: That won't work with the fullscreen_monitors case */
-	    if (w->type () & CompWindowTypeFullscreenMask)
-	    {
-		g = compiz::window::Geometry (w->serverGeometry ());
-		g.applyChange (compiz::window::Geometry (vpX * newWidth,
-							 vpY * newHeight,
-							 newWidth,
-							 newHeight,
-							 0), CHANGE_X |
-							     CHANGE_Y |
-							     CHANGE_WIDTH |
-							     CHANGE_HEIGHT);
-	    }
-	    else
-	    {
-		if (w->state () & CompWindowStateMaximizedHorzMask)
-		{
-		    g.setX (vpX * newWidth + workArea.x () + w->border ().left);
-		    g.setWidth (workArea.width () -
-				(2 * w->serverGeometry ().border () +
-				 w->border ().left + w->border ().right));
-		}
-		if (w->state () & CompWindowStateMaximizedVertMask)
-		{
-		    g.setY (vpY * newHeight + workArea.y () + w->border ().top);
-		    g.setHeight (workArea.height () -
-				 (2 * w->serverGeometry ().border () +
-				  w->border ().top + w->border ().bottom));
-		}
-	    }
-	}
-
-	/* actually move/resize window in directions given by mask */
-	w->positionSetEnabled (PlaceWindow::get (w), false);
-	w->position (g, 0);
-	w->positionSetEnabled (PlaceWindow::get (w), true);
-
-	if ((w->actions () & MAXIMIZE_STATE) == MAXIMIZE_STATE &&
-	    (w->mwmDecor () & (MwmDecorAll | MwmDecorTitle))   &&
-	    !(w->state () & CompWindowStateFullscreenMask))
-	{
-	    if (og.width () >= workArea.width () &&
-		og.height () >= workArea.height ())
-	    {
-		PlaceWindow::get (w)->sendMaximizationRequest ();
-	    }
+	if (!firstPass)
+	    pw->adjustForSize (mPrevSize, CompSize (newWidth, newHeight));
+
+    }
+}
+
+const compiz::window::Geometry &
+PlaceWindow::getGeometry () const
+{
+    return window->serverGeometry ();
+}
+
+const CompPoint &
+PlaceWindow::getViewport () const
+{
+    return screen->vp ();
+}
+
+const CompRect &
+PlaceWindow::getWorkarea (const compiz::window::Geometry &g) const
+{
+    return screen->getWorkareaForOutput (screen->outputDeviceForGeometry (g));
+}
+
+const compiz::window::extents::Extents &
+PlaceWindow::getExtents () const
+{
+    return window->border ();
+}
+
+void
+PlaceWindow::applyGeometry (compiz::window::Geometry &ng,
+			    compiz::window::Geometry &og)
+{
+    CompRect workArea = screen->getWorkareaForOutput (
+			    screen->outputDeviceForGeometry (og));
+
+    window->positionSetEnabled (this, false);
+    window->position (ng, 0, 0);
+    window->positionSetEnabled (this, true);
+
+    if ((window->actions () & MAXIMIZE_STATE) == MAXIMIZE_STATE &&
+	(window->mwmDecor () & (MwmDecorAll | MwmDecorTitle))   &&
+	!(window->state () & CompWindowStateFullscreenMask))
+    {
+	if (og.width () >= workArea.width () &&
+	    og.height () >= workArea.height ())
+	{
+	    sendMaximizationRequest ();
 	}
     }
 }
@@ -275,9 +155,13 @@
     /* If countdown is not finished yet (i.e. at least one struct window didn't
      * update its struts), reset the count down and do the 2nd pass here */
 
-    if (mStrutWindowCount > 0) /* no windows with struts found */
+    if (!mStrutWindows.empty ()) /* no windows with struts found */
     {
-	mStrutWindowCount = 0;
+	compLogMessage ("place", CompLogLevelWarn, "broken clients didn't update their struts");
+	foreach (CompWindow *w, mStrutWindows)
+	    compLogMessage ("place", CompLogLevelWarn, "client id: 0x%x", w->id ());
+
+	mStrutWindows.clear ();
 	doHandleScreenSizeChange (false, width, height);
     }
 
@@ -288,17 +172,17 @@
 PlaceScreen::handleScreenSizeChange (int width,
 				     int height)
 {
-    CompRect       extents;
-
     if (mPrevSize.width () == width && mPrevSize.height () == height)
 	return;
 
     if (mResChangeFallbackHandle.active ())
 	mResChangeFallbackHandle.stop ();
 
+    mStrutWindows = compiz::place::collectStrutWindows (screen->windows ());
+
     doHandleScreenSizeChange (true, width, height);
 
-    if (mStrutWindowCount == 0) /* no windows with struts found */
+    if (mStrutWindows.empty ()) /* no windows with struts found */
     {
 	mResChangeFallbackHandle.stop ();
 	/* do the 2nd pass right here instead of handleEvent */
@@ -361,16 +245,18 @@
 	        {
 		    /* Only do when handling screen size change.
 		       ps->strutWindowCount is 0 at any other time */
-		    if (mStrutWindowCount > 0 &&
-		        w->updateStruts ())
+		    if (std::find (mStrutWindows.begin (),
+				   mStrutWindows.end (),
+				   w) != mStrutWindows.end ())
 		    {
-		        mStrutWindowCount--;
-		        screen->updateWorkarea ();
+			mStrutWindows.remove (w);
 
 		        /* if this was the last window with struts */
-		        if (!mStrutWindowCount)
+			if (mStrutWindows.empty ())
+			{
 			    doHandleScreenSizeChange (false, screen->width (),
 			    				     screen->height ()); /* 2nd pass */
+			}
 		    }
 	        }
 	    }
@@ -426,7 +312,7 @@
 
 PlaceWindow::PlaceWindow (CompWindow *w) :
     PluginClassHandler<PlaceWindow, CompWindow> (w),
-    mSavedOriginal (false),
+    compiz::place::ScreenSizeChangeObject (w->serverGeometry ()),
     window (w),
     ps (PlaceScreen::get (screen))
 {
@@ -1558,12 +1444,11 @@
 			 unsigned int state,
 			 unsigned int mask)
 {
-    if (mSavedOriginal)
-    {
-	if (screen->grabExist ("move") ||
-	    screen->grabExist ("resize"))
-	    mSavedOriginal = false;
-    }
+    /* Remove all bits if the user
+     * moves the window */
+    if (screen->grabExist ("move") ||
+	screen->grabExist ("resize"))
+	unset ();
 
     window->grabNotify (x, y, state, mask);
 }

=== modified file 'plugins/place/src/place.h'
--- plugins/place/src/place.h	2012-01-13 13:20:02 +0000
+++ plugins/place/src/place.h	2012-01-13 13:20:03 +0000
@@ -31,6 +31,15 @@
 
 #include "place_options.h"
 #include "constrain-to-workarea.h"
+#include "screen-size-change.h"
+
+namespace compiz
+{
+namespace place
+{
+CompWindowList collectStrutWindows (const CompWindowList &all);
+}
+}
 
 class PlaceScreen :
     public PluginClassHandler<PlaceScreen, CompScreen>,
@@ -51,6 +60,7 @@
 	CompSize mPrevSize;
 	int	 mStrutWindowCount;
 	CompTimer mResChangeFallbackHandle;
+	CompWindowList mStrutWindows;
 	
 	Atom fullPlacementAtom;
 };
@@ -60,6 +70,7 @@
 
 class PlaceWindow :
     public PluginClassHandler<PlaceWindow, CompWindow>,
+    public compiz::place::ScreenSizeChangeObject,
     public WindowInterface
 {
     public:
@@ -70,12 +81,17 @@
 	bool position (compiz::window::Geometry &g,
 		       unsigned int source,
 		       unsigned int constrainment);
-	void grabNotify (int, int, unsigned int, unsigned int);    
-	bool mSavedOriginal;
-	CompRect mOrigVpRelRect;
+	void grabNotify (int, int, unsigned int, unsigned int);
 	CompPoint mPrevServer;
-	
-	void sendMaximizationRequest ();
+
+    protected:
+
+	void applyGeometry (compiz::window::Geometry &,
+			    compiz::window::Geometry &);
+	const compiz::window::Geometry & getGeometry () const;
+	const CompPoint & getViewport () const;
+	const CompRect & getWorkarea (const compiz::window::Geometry &g) const;
+	const compiz::window::extents::Extents & getExtents () const;
 
     private:
 	typedef enum {
@@ -87,6 +103,8 @@
 	    PlaceCenteredOnScreen
 	} PlacementStrategy;
 
+	void sendMaximizationRequest ();
+
 	void doPlacement (CompPoint &pos);
 	bool windowIsPlaceRelevant (CompWindow *w);
 	bool hasUserDefinedPosition (bool);

=== added directory 'plugins/place/src/screen-size-change'
=== added file 'plugins/place/src/screen-size-change/CMakeLists.txt'
--- plugins/place/src/screen-size-change/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/place/src/screen-size-change/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -0,0 +1,76 @@
+pkg_check_modules (
+  GLIBMM
+  REQUIRED
+  glibmm-2.4 glib-2.0
+)
+
+INCLUDE_DIRECTORIES (  
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+
+  ${compiz_SOURCE_DIR}/plugins/place/src/constrain-to-workarea/include
+  ${compiz_SOURCE_DIR}/src/point/include
+  ${compiz_SOURCE_DIR}/src/rect/include
+  ${compiz_SOURCE_DIR}/src/window/geometry/include
+  ${compiz_SOURCE_DIR}/src/window/geometry-saver/include
+  ${compiz_SOURCE_DIR}/src/window/extents/include
+  ${compiz_SOURCE_DIR}/include
+    
+  ${Boost_INCLUDE_DIRS}
+  
+  ${GLIBMM_INCLUDE_DIRS}
+)
+
+LINK_DIRECTORIES (${GLIBMM_LIBRARY_DIRS}) 
+
+SET ( 
+  PUBLIC_HEADERS 
+)
+
+SET ( 
+  PRIVATE_HEADERS
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/screen-size-change.h
+)
+
+SET( 
+  SRCS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/screen-size-change.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_place_screen_size_change STATIC
+  
+  ${SRCS}
+  
+  ${PUBLIC_HEADERS}
+  ${PRIVATE_HEADERS}
+)
+
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+
+SET_TARGET_PROPERTIES(
+  compiz_place_screen_size_change PROPERTIES
+  PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
+)
+
+INSTALL(
+  TARGETS                                 compiz_place_screen_size_change
+  RUNTIME             DESTINATION         bin
+  LIBRARY             DESTINATION         lib
+  ARCHIVE             DESTINATION         lib
+  PUBLIC_HEADER       DESTINATION         include/compiz
+)
+
+
+
+TARGET_LINK_LIBRARIES(
+  compiz_place_screen_size_change
+  compiz_place_constrain_to_workarea
+  compiz_rect
+  compiz_point
+  compiz_window_geometry
+  compiz_window_geometry_saver
+
+  ${GLIBMM_LIBRARIES}
+)

=== added directory 'plugins/place/src/screen-size-change/include'
=== added file 'plugins/place/src/screen-size-change/include/screen-size-change.h'
--- plugins/place/src/screen-size-change/include/screen-size-change.h	1970-01-01 00:00:00 +0000
+++ plugins/place/src/screen-size-change/include/screen-size-change.h	2012-01-13 13:20:03 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef _COMPIZ_PLACE_SCREEN_SIZE_CHANGE_H
+#define _COMPIZ_PLACE_SCREEN_SIZE_CHANGE_H
+
+#include <core/rect.h>
+#include <core/windowgeometry.h>
+#include <core/windowgeometrysaver.h>
+#include <core/windowextents.h>
+#include <core/size.h>
+#include <core/point.h>
+
+#include "constrain-to-workarea.h"
+
+namespace compiz
+{
+namespace place
+{
+
+class ScreenSizeChangeObject
+{
+    public:
+
+	ScreenSizeChangeObject (const compiz::window::Geometry &g);
+	virtual ~ScreenSizeChangeObject ();
+
+	virtual const compiz::window::Geometry & getGeometry () const = 0;
+	virtual void applyGeometry (compiz::window::Geometry &ng,
+				    compiz::window::Geometry &og) = 0;
+	virtual const CompPoint & getViewport () const = 0;
+	virtual const CompRect & getWorkarea (const compiz::window::Geometry &g) const = 0;
+	virtual const compiz::window::extents::Extents & getExtents () const = 0;
+
+	compiz::window::Geometry adjustForSize (const CompSize &oldSize,
+						const CompSize &newSize);
+
+	void unset ();
+
+    private:
+
+	compiz::window::GeometrySaver mSaver;
+};
+
+}
+}
+
+#endif

=== added directory 'plugins/place/src/screen-size-change/src'
=== added file 'plugins/place/src/screen-size-change/src/screen-size-change.cpp'
--- plugins/place/src/screen-size-change/src/screen-size-change.cpp	1970-01-01 00:00:00 +0000
+++ plugins/place/src/screen-size-change/src/screen-size-change.cpp	2012-01-13 13:20:03 +0000
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "screen-size-change.h"
+
+
+compiz::place::ScreenSizeChangeObject::ScreenSizeChangeObject (const compiz::window::Geometry &g) :
+    mSaver (g)
+{
+}
+
+compiz::place::ScreenSizeChangeObject::~ScreenSizeChangeObject ()
+{
+}
+
+compiz::window::Geometry
+compiz::place::ScreenSizeChangeObject::adjustForSize (const CompSize &oldSize,
+						      const CompSize &newSize)
+{
+    int            vpX, vpY, shiftX, shiftY;
+    compiz::window::Geometry g, vpRelRect;
+    int		   pivotX, pivotY;
+    int		   curVpOffsetX = getViewport ().x () * newSize.width ();
+    int		   curVpOffsetY = getViewport ().y () * newSize.height ();
+
+    g = getGeometry ();
+
+    pivotX = g.x ();
+    pivotY = g.y ();
+
+    /* FIXME: Should use saved geometry for maximized / fullscreen windows */
+
+    /* calculate target vp x, y index for window's pivot point */
+    vpX = pivotX / oldSize.width ();
+    if (pivotX < 0)
+	vpX -= 1;
+    vpY = pivotY / oldSize.height ();
+    if (pivotY < 0)
+	vpY -= 1;
+
+    /* if window's target vp is to the left of the leftmost viewport on that
+       row, assign its target vp column as 0 (-s->x rel. to current vp) */
+    if (getViewport ().x () + vpX < 0)
+	vpX = -getViewport ().x ();
+
+    /* if window's target vp is above the topmost viewport on that column,
+       assign its target vp row as 0 (-s->y rel. to current vp) */
+    if (getViewport ().y () + vpY < 0)
+	vpY = -getViewport ().y ();
+
+    unsigned int mask = mSaver.pop (vpRelRect, CHANGE_X | CHANGE_Y |
+					       CHANGE_WIDTH | CHANGE_HEIGHT);
+
+    if (mask)
+    {
+	/* set position/size to saved original rectangle */
+	g.applyChange (compiz::window::Geometry (vpRelRect.x () + vpX * newSize.width (),
+						 vpRelRect.y () + vpY * newSize.height (),
+						 vpRelRect.width (),
+						 vpRelRect.height (),
+						 vpRelRect.border ()), mask);
+    }
+    else
+    {
+	/* set position/size to window's current rectangle
+	   (with position relative to target viewport) */
+	vpRelRect.setX (g.x () - vpX * oldSize.width ());
+	vpRelRect.setY (g.y () - vpY * oldSize.height ());
+	vpRelRect.setWidth (g.width ());
+	vpRelRect.setHeight (g.height ());
+
+	g.setPos (g.pos ());
+
+	shiftX = vpX * (newSize.width () - oldSize.width ());
+	shiftY = vpY * (newSize.width () - oldSize.height ());
+
+	/* if coords. relative to viewport are outside new viewport area,
+	   shift window left/up so that it falls inside */
+	if (vpRelRect.x () >= newSize.width ())
+	    shiftX -= vpRelRect.x () - (newSize.width () - 1);
+	if (vpRelRect.y () >= newSize.height ())
+	    shiftY -= vpRelRect.y () - (newSize.height () - 1);
+
+	if (shiftX)
+	    g.setX (g.x () + shiftX);
+
+	if (shiftY)
+	    g.setY (g.y () + shiftY);
+
+	g.setWidth (vpRelRect.width ());
+	g.setHeight (vpRelRect.height ());
+    }
+
+    /* Handle non-(0,0) current viewport by shifting by curVpOffsetX,Y,
+       and bring window to (0,0) by shifting by minus its vp offset */
+
+    g.setX (g.x () + curVpOffsetX - (getViewport ().x () + vpX) * newSize.width ());
+    g.setY (g.y () + curVpOffsetY - (getViewport ().y () + vpY) * newSize.height ());
+
+    unsigned int flags = 0;
+
+    compiz::window::Geometry og (g);
+    const CompRect &workArea = getWorkarea (g);
+
+    compiz::place::clampGeometryToWorkArea (g, workArea, getExtents (), flags, newSize);
+
+    g.setX (g.x () - curVpOffsetX + (getViewport ().x () + vpX) * newSize.width ());
+    g.setY (g.y () - curVpOffsetY + (getViewport ().y () + vpY) * newSize.height ());
+
+    if (!mask)
+    {
+	/* save window geometry (relative to viewport) so that it
+	can be restored later */
+	mask = getGeometry ().changeMask (g);
+	mSaver.push (vpRelRect, mask);
+    }
+    else
+    {
+	compiz::window::Geometry rg (vpRelRect.x () + vpX * newSize.width (),
+				     vpRelRect.y () + vpY * newSize.height (),
+				     vpRelRect.width (),
+				     vpRelRect.height (), vpRelRect.border ());
+
+	/* Don't care about any bits not restored */
+	rg.applyChange (g, ~mask);
+
+	/* Push any bits back on the saver
+	 * that don't match the requested window geometry
+	 * since we will need to restore to them later */
+
+	unsigned int remaining = g.changeMask (rg);
+	mSaver.push (vpRelRect, remaining);
+    }
+
+    /* for maximized/fullscreen windows, update saved pos/size XXX,
+     * also pull in the old code to handle maximized windows which
+     * currently can't be implemented yet */
+
+    /* actually move/resize window in directions given by mask */
+    applyGeometry (g, og);
+
+    return g;
+}
+
+void
+compiz::place::ScreenSizeChangeObject::unset ()
+{
+    compiz::window::Geometry g;
+    mSaver.pop (g, !0);
+}

=== added directory 'plugins/place/src/screen-size-change/tests'
=== added file 'plugins/place/src/screen-size-change/tests/CMakeLists.txt'
--- plugins/place/src/screen-size-change/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/place/src/screen-size-change/tests/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -0,0 +1,18 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+add_library (compiz_place_screen_size_change_test
+             ${CMAKE_CURRENT_SOURCE_DIR}/test-screen-size-change.cpp)
+
+add_executable (compiz_test_place_screen_size_change
+                ${CMAKE_CURRENT_SOURCE_DIR}/screen-size-change/src/test-place-screen-size-change.cpp)
+
+target_link_libraries (compiz_test_place_screen_size_change
+                       compiz_place_screen_size_change_test
+                       compiz_place_screen_size_change
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread. 
+                       )
+
+add_test (compiz_place_screen_size_change compiz_test_place_screen_size_change)

=== added directory 'plugins/place/src/screen-size-change/tests/screen-size-change'
=== added directory 'plugins/place/src/screen-size-change/tests/screen-size-change/src'
=== added file 'plugins/place/src/screen-size-change/tests/screen-size-change/src/test-place-screen-size-change.cpp'
--- plugins/place/src/screen-size-change/tests/screen-size-change/src/test-place-screen-size-change.cpp	1970-01-01 00:00:00 +0000
+++ plugins/place/src/screen-size-change/tests/screen-size-change/src/test-place-screen-size-change.cpp	2012-01-13 13:20:03 +0000
@@ -0,0 +1,324 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <test-screen-size-change.h>
+#include <screen-size-change.h>
+#include <iostream>
+#include <stdlib.h>
+#include <cstring>
+
+class CompPlaceScreenSizeChangeTestScreenSizeChange :
+    public CompPlaceScreenSizeChangeTest
+{
+public:
+
+    CompPlaceScreenSizeChangeTestScreenSizeChange ();
+    ~CompPlaceScreenSizeChangeTestScreenSizeChange ();
+};
+
+CompPlaceScreenSizeChangeTestScreenSizeChange::CompPlaceScreenSizeChangeTestScreenSizeChange ()
+{
+}
+
+CompPlaceScreenSizeChangeTestScreenSizeChange::~CompPlaceScreenSizeChangeTestScreenSizeChange ()
+{
+}
+
+class MockScreenSizeChangeObject :
+    public compiz::place::ScreenSizeChangeObject
+{
+    public:
+
+	MockScreenSizeChangeObject (const compiz::window::Geometry &);
+	~MockScreenSizeChangeObject ();
+
+	const compiz::window::Geometry & getGeometry () const;
+	void applyGeometry (compiz::window::Geometry &n,
+			    compiz::window::Geometry &o);
+	const CompPoint & getViewport () const;
+	const CompRect &  getWorkarea (const compiz::window::Geometry &g) const;
+	const compiz::window::extents::Extents & getExtents () const;
+
+	void setVp (const CompPoint &);
+	void setWorkArea (const CompRect &);
+	void setExtents (unsigned int left,
+			 unsigned int right,
+			 unsigned int top,
+			 unsigned int bottom);
+
+	void setGeometry (const compiz::window::Geometry &g);
+
+    private:
+
+	CompPoint			 mCurrentVp;
+	CompRect			 mCurrentWorkArea;
+	compiz::window::extents::Extents mCurrentExtents;
+	compiz::window::Geometry         mCurrentGeometry;
+};
+
+MockScreenSizeChangeObject::MockScreenSizeChangeObject (const compiz::window::Geometry &g) :
+    ScreenSizeChangeObject (g),
+    mCurrentVp (0, 0),
+    mCurrentWorkArea (50, 50, 1000, 1000),
+    mCurrentGeometry (g)
+{
+    memset (&mCurrentExtents, 0, sizeof (compiz::window::extents::Extents));
+}
+
+MockScreenSizeChangeObject::~MockScreenSizeChangeObject ()
+{
+}
+
+const compiz::window::Geometry &
+MockScreenSizeChangeObject::getGeometry () const
+{
+    return mCurrentGeometry;
+}
+
+void
+MockScreenSizeChangeObject::applyGeometry (compiz::window::Geometry &n,
+					   compiz::window::Geometry &o)
+{
+    std::cout << "DEBUG: new geometry : " << n.x () << " "
+					  << n.y () << " "
+					  << n.width () << " "
+					  << n.height () << " "
+					  << n.border () << std::endl;
+
+    std::cout << "DEBUG: old geometry : " << o.x () << " "
+					  << o.y () << " "
+					  << o.width () << " "
+					  << o.height () << " "
+					  << o.border () << std::endl;
+
+    mCurrentGeometry = n;
+}
+
+const CompPoint &
+MockScreenSizeChangeObject::getViewport () const
+{
+    return mCurrentVp;
+}
+
+const CompRect &
+MockScreenSizeChangeObject::getWorkarea (const compiz::window::Geometry &g) const
+{
+    return mCurrentWorkArea;
+}
+
+const compiz::window::extents::Extents &
+MockScreenSizeChangeObject::getExtents () const
+{
+    return mCurrentExtents;
+}
+
+void
+MockScreenSizeChangeObject::setVp (const CompPoint &p)
+{
+    mCurrentVp = p;
+}
+
+void
+MockScreenSizeChangeObject::setWorkArea (const CompRect &wa)
+{
+    mCurrentWorkArea = wa;
+}
+
+void
+MockScreenSizeChangeObject::setExtents (unsigned int left,
+				        unsigned int right,
+					unsigned int top,
+					unsigned int bottom)
+{
+    mCurrentExtents.left = left;
+    mCurrentExtents.right = right;
+    mCurrentExtents.top = top;
+    mCurrentExtents.bottom = bottom;
+}
+
+void
+MockScreenSizeChangeObject::setGeometry (const compiz::window::Geometry &g)
+{
+    mCurrentGeometry = g;
+}
+
+void
+reserveStruts (CompRect &workArea)
+{
+    workArea.setLeft (workArea.left () + 24);
+    workArea.setTop (workArea.top () + 24);
+    workArea.setBottom (workArea.bottom () - 24);
+}
+
+TEST_F (CompPlaceScreenSizeChangeTestScreenSizeChange, TestScreenSizeChange)
+{
+    CompSize		     current, old;
+    compiz::window::Geometry g (200, 250, 300, 400, 0);
+
+    MockScreenSizeChangeObject *ms = new MockScreenSizeChangeObject (g);
+
+    current = CompSize (1280, 800);
+
+    /* Reserve top, bottom and left parts of the screen for
+     * fake "24px" panels */
+    CompRect workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    /* First test that changing the screen size
+     * to something smaller here doesn't cause our
+     * (small) window to be moved */
+
+    old = current;
+    current = CompSize (1024, 768);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (200, 250, 300, 400, 0));
+
+    /* Making the screen size bigger with no
+     * saved geometry should cause the window not to move */
+
+    old = current;
+    current = CompSize (2048, 768);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (200, 250, 300, 400, 0));
+
+    /* Move the window to the other "monitor" */
+
+    ms->setGeometry (compiz::window::Geometry (1025, 250, 300, 400, 0));
+
+    old = current;
+
+    /* Unplug a "monitor" */
+    current = CompSize (1024, 768);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (724, 250, 300, 400, 0));
+
+    old = current;
+
+    /* Re-plug the monitor - window should go back
+     * to the same position */
+    current = CompSize (2048, 768);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (1025, 250, 300, 400, 0));
+
+    old = current;
+
+    /* Plug 2 monitors downwards, no change */
+    current = CompSize (2048, 1536);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (1025, 250, 300, 400, 0));
+
+    /* Move the window to the bottom "monitor" */
+
+    ms->setGeometry (compiz::window::Geometry (1025, 791, 300, 400, 0));
+
+    old = current;
+
+    /* Unplug bottom "monitor" */
+    current = CompSize (2048, 768);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (1025, 344, 300, 400, 0));
+
+    old = current;
+
+    /* Re-plug bottom "monitor" */
+    current = CompSize (2048, 1356);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (1025, 791, 300, 400, 0));
+
+    /* Move the entire window right a viewport */
+
+    g.setPos (g.pos () + CompPoint (current.width (), 0));
+
+    ms->setGeometry (g);
+
+    /* Now change the screen resolution again - the window should
+     * move to be within the constrained size of its current
+     * viewport */
+
+    /* Unplug a "monitor" */
+    old = current;
+    current = CompSize (1024, 1356);
+
+    workArea = CompRect (0, 0, current.width (), current.height ());
+    reserveStruts (workArea);
+
+    ms->setWorkArea (workArea);
+
+    g = ms->adjustForSize (old, current);
+
+    EXPECT_EQ (g, compiz::window::Geometry (current.width () + 724, 791, 300, 400, 0));
+}
+

=== added file 'plugins/place/src/screen-size-change/tests/test-screen-size-change.cpp'
--- plugins/place/src/screen-size-change/tests/test-screen-size-change.cpp	1970-01-01 00:00:00 +0000
+++ plugins/place/src/screen-size-change/tests/test-screen-size-change.cpp	2012-01-13 13:20:03 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include "test-screen-size-change.h"
+
+CompPlaceScreenSizeChangeTest::CompPlaceScreenSizeChangeTest ()
+{
+}
+
+CompPlaceScreenSizeChangeTest::~CompPlaceScreenSizeChangeTest ()
+{
+}

=== added file 'plugins/place/src/screen-size-change/tests/test-screen-size-change.h'
--- plugins/place/src/screen-size-change/tests/test-screen-size-change.h	1970-01-01 00:00:00 +0000
+++ plugins/place/src/screen-size-change/tests/test-screen-size-change.h	2012-01-13 13:20:03 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#ifndef _COMPIZ_TEST_PLACE_SCREEN_SIZE_CHANGE_H
+#define _COMPIZ_TEST_PLACE_SCREEN_SIZE_CHANGE_H
+
+#include <gtest/gtest.h>
+#include <core/rect.h>
+#include <core/windowgeometry.h>
+#include <core/windowgeometrysaver.h>
+#include <core/windowextents.h>
+#include <core/size.h>
+#include <core/point.h>
+#include <string>
+#include <iostream>
+#include <stdlib.h>
+
+class CompPlaceScreenSizeChangeTest :
+    public ::testing::Test
+{
+public:
+
+    CompPlaceScreenSizeChangeTest ();
+    virtual ~CompPlaceScreenSizeChangeTest ();
+};
+
+#endif

=== removed directory 'plugins/place/tests'
=== removed file 'plugins/place/tests/CMakeLists.txt'
=== removed directory 'plugins/place/tests/place'
=== modified file 'plugins/resize/src/resize.cpp'
--- plugins/resize/src/resize.cpp	2012-01-13 13:20:02 +0000
+++ plugins/resize/src/resize.cpp	2012-01-13 13:20:03 +0000
@@ -885,7 +885,12 @@
 	cwi = wi;
 	che = he;
 
-	if (w->constrainNewWindowSize (wi, he, &cwi, &che) &&
+	CompSize size (wi, he);
+	CompSize constrained =
+		compiz::window::constrainment::constrainToHints (w,
+								 size);
+
+	if (constrained != size &&
 	    mode != ResizeOptions::ModeNormal)
 	{
 	    Box box;
@@ -900,6 +905,9 @@
 	    damageRectangle (&box);
 	}
 
+	cwi = constrained.width ();
+	che = constrained.height ();
+
 	/* constrain to work area */
 	if (offWorkAreaConstrained)
 	{

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ src/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -57,6 +57,9 @@
 
     ${CMAKE_CURRENT_SOURCE_DIR}/window/extents/include
     ${CMAKE_CURRENT_SOURCE_DIR}/window/extents/src
+
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/constrainment/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/constrainment/src
 )
 
 add_definitions (
@@ -121,6 +124,7 @@
     compiz_window_geometry
     compiz_window_geometry_saver
     compiz_window_extents
+    compiz_window_constrainment
 #    ${CORE_MOD_LIBRARIES}
 )
 

=== modified file 'src/logmessage/CMakeLists.txt'
--- src/logmessage/CMakeLists.txt	2012-01-12 08:35:59 +0000
+++ src/logmessage/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -26,6 +26,7 @@
 SET_TARGET_PROPERTIES(
   compiz_logmessage PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/pluginclasshandler/CMakeLists.txt'
--- src/pluginclasshandler/CMakeLists.txt	2012-01-12 08:35:59 +0000
+++ src/pluginclasshandler/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -40,6 +40,7 @@
 SET_TARGET_PROPERTIES(
   compiz_pluginclasshandler PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/pluginclasshandler/src/valueholder.h'
--- src/pluginclasshandler/src/valueholder.h	2011-10-31 13:51:00 +0000
+++ src/pluginclasshandler/src/valueholder.h	2012-01-13 13:20:03 +0000
@@ -30,6 +30,7 @@
     public:
 
 	ValueHolder ();
+	virtual ~ValueHolder () { delete priv; };
 
 	void hasValue (CompString key);
 	void storeValue (CompString key, CompPrivate value);

=== modified file 'src/pluginclasshandler/tests/test-pluginclasshandler.h'
--- src/pluginclasshandler/tests/test-pluginclasshandler.h	2011-12-19 07:06:22 +0000
+++ src/pluginclasshandler/tests/test-pluginclasshandler.h	2012-01-13 13:20:03 +0000
@@ -23,6 +23,7 @@
     public:
 
 	Global ();
+	~Global () {}
 
 	std::list <Base *> bases;
 };

=== modified file 'src/point/CMakeLists.txt'
--- src/point/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ src/point/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -48,6 +48,7 @@
 SET_TARGET_PROPERTIES(
   compiz_point PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/rect/CMakeLists.txt'
--- src/rect/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ src/rect/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -46,6 +46,7 @@
 SET_TARGET_PROPERTIES(
   compiz_rect PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/screen.cpp'
--- src/screen.cpp	2012-01-13 13:20:02 +0000
+++ src/screen.cpp	2012-01-13 13:20:03 +0000
@@ -4141,8 +4141,8 @@
     return priv->screenNum;
 }
 
-CompPoint
-CompScreen::vp ()
+const CompPoint &
+CompScreen::vp () const
 {
     return priv->vp;
 }

=== modified file 'src/size.cpp'
--- src/size.cpp	2009-07-30 23:21:10 +0000
+++ src/size.cpp	2012-01-13 13:20:03 +0000
@@ -48,3 +48,16 @@
 {
     mHeight = height;
 }
+
+bool
+CompSize::operator== (const CompSize &other) const
+{
+    return (width () == other.width () &&
+	    height () == other.height ());
+}
+
+bool
+CompSize::operator!= (const CompSize &other) const
+{
+    return !(*this == other);
+}

=== modified file 'src/string/CMakeLists.txt'
--- src/string/CMakeLists.txt	2011-12-19 07:06:22 +0000
+++ src/string/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -24,6 +24,7 @@
 SET_TARGET_PROPERTIES(
   compiz_string PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/timer/CMakeLists.txt'
--- src/timer/CMakeLists.txt	2012-01-12 08:35:59 +0000
+++ src/timer/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -51,6 +51,7 @@
 SET_TARGET_PROPERTIES(
   compiz_timer PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/window.cpp'
--- src/window.cpp	2012-01-13 13:20:02 +0000
+++ src/window.cpp	2012-01-13 13:20:03 +0000
@@ -3765,12 +3765,11 @@
     if (state & CompWindowStateFullscreenMask ||
 	state & CompWindowStateMaximizedHorzMask)
     {
-	int width = old.width ();
-	int height = old.height ();
-
-	window->constrainNewWindowSize (width, height, &width, &height);
-
-	if (width > output->width ())
+	CompSize size = CompSize (old.width (), old.height ());
+	size = compiz::window::constrainment::constrainToHints (window,
+								size);
+
+	if (size.width () > output->width ())
 	{
 	    int        distance = std::numeric_limits <int>::max ();
 	    CompOutput *selected = output;
@@ -3778,7 +3777,7 @@
 	     * which has a large enough size */
 	    foreach (CompOutput &o, screen->outputDevs ())
 	    {
-		if (o.workArea ().width () > width)
+		if (o.workArea ().width () > size.width ())
 		{
 		    int tDistance = sqrt (pow (abs (o.x () - output->x ()), 2) +
 					  pow (abs (o.y () - output->y ()), 2));
@@ -3798,12 +3797,11 @@
     if (state & CompWindowStateFullscreenMask ||
 	state & CompWindowStateMaximizedVertMask)
     {
-	int width = old.width ();
-	int height = old.height ();
-
-	window->constrainNewWindowSize (width, height, &width, &height);
-
-	if (height > output->height ())
+	CompSize size = CompSize (old.width (), old.height ());
+	size = compiz::window::constrainment::constrainToHints (window,
+								size);
+
+	if (size.height () > output->height ())
 	{
 	    int        distance = std::numeric_limits <int>::max ();
 	    CompOutput *selected = output;
@@ -3811,7 +3809,7 @@
 	     * which has a large enough size */
 	    foreach (CompOutput &o, screen->outputDevs ())
 	    {
-		if (o.workArea ().height () > height)
+		if (o.workArea ().height () > size.height ())
 		{
 		    int tDistance = sqrt (pow (abs (o.x () - output->x ()), 2) +
 					  pow (abs (o.y () - output->y ()), 2));
@@ -3851,7 +3849,7 @@
     output = selectOutputForGeometry (old);
     workArea = output->workArea ();
 
-    if (!priv->placed)
+    if (priv->placed)
     {
 	if (type & CompWindowTypeFullscreenMask)
 	{
@@ -3943,15 +3941,18 @@
 	    if (changeMask & (CHANGE_WIDTH | CHANGE_HEIGHT))
 	    {
 		compiz::window::Geometry constrained = old;
+		CompSize                 size;
 		int width, height, max;
 
 		constrained.applyChange (ng, changeMask);
 		ng.setSize (CompSize (old.width (), old.height ()));
-
-		width = constrained.width ();
-		height = constrained.height ();
-
-		window->constrainNewWindowSize (width, height, &width, &height);
+		size =
+		   compiz::window::constrainment::constrainToHints (window,
+								    CompSize (constrained.width (),
+									      constrained.height ()));
+
+		width = size.width ();
+		height = size.height ();
 
 		if (width != (int) old.width ())
 		{
@@ -3969,6 +3970,7 @@
 		else
 		    changeMask &= ~CHANGE_HEIGHT;
 
+
 		if (state & CompWindowStateMaximizedVertMask)
 		{
 		    /* If the window is still offscreen, then we need to constrain it
@@ -4167,9 +4169,11 @@
 
     if (changeMask & (CHANGE_WIDTH | CHANGE_HEIGHT))
     {
-	int width, height;
+	CompSize size = compiz::window::constrainment::constrainToHints (window,
+									 CompSize (ng.width (),
+										   ng.height ()));
 
-	if (window->constrainNewWindowSize (ng.width (), ng.height (), &width, &height))
+	if (size.width () != ng.width () && size.height () != ng.height ())
 	{
 	    if (width != ng.width ())
 		changeMask |= CHANGE_WIDTH;
@@ -4697,158 +4701,38 @@
     moveInputFocusTo ();
 }
 
-
-#define PVertResizeInc (1 << 0)
-#define PHorzResizeInc (1 << 1)
-
-bool
-CompWindow::constrainNewWindowSize (int        width,
-				    int        height,
-				    int        *newWidth,
-				    int        *newHeight)
-{
-    const XSizeHints *hints = &priv->sizeHints;
-    int              oldWidth = width;
-    int              oldHeight = height;
-    int		     min_width = 0;
-    int		     min_height = 0;
-    int		     base_width = 0;
-    int		     base_height = 0;
-    int		     xinc = 1;
-    int		     yinc = 1;
-    int		     max_width = MAXSHORT;
-    int		     max_height = MAXSHORT;
-    long	     flags = hints->flags;
-    long	     resizeIncFlags = (flags & PResizeInc) ? ~0 : 0;
-
-    if (screen->priv->optionGetIgnoreHintsWhenMaximized ())
-    {
-	if (priv->state & MAXIMIZE_STATE)
-	{
-	    flags &= ~PAspect;
-
-	    if (priv->state & CompWindowStateMaximizedHorzMask)
-		resizeIncFlags &= ~PHorzResizeInc;
-
-	    if (priv->state & CompWindowStateMaximizedVertMask)
-		resizeIncFlags &= ~PVertResizeInc;
-	}
-    }
-
-    /* Ater gdk_window_constrain_size(), which is partially borrowed from fvwm.
-     *
-     * Copyright 1993, Robert Nation
-     *     You may use this code for any purpose, as long as the original
-     *     copyright remains in the source code and all documentation
-     *
-     * which in turn borrows parts of the algorithm from uwm
-     */
-
-#define FLOOR(value, base) (((int) ((value) / (base))) * (base))
-#define FLOOR64(value, base) (((uint64_t) ((value) / (base))) * (base))
-
-    if ((flags & PBaseSize) && (flags & PMinSize))
-    {
-	base_width = hints->base_width;
-	base_height = hints->base_height;
-	min_width = hints->min_width;
-	min_height = hints->min_height;
-    }
-    else if (flags & PBaseSize)
-    {
-	base_width = hints->base_width;
-	base_height = hints->base_height;
-	min_width = hints->base_width;
-	min_height = hints->base_height;
-    }
-    else if (flags & PMinSize)
-    {
-	base_width = hints->min_width;
-	base_height = hints->min_height;
-	min_width = hints->min_width;
-	min_height = hints->min_height;
-    }
-
-    if (flags & PMaxSize)
-    {
-	max_width = hints->max_width;
-	max_height = hints->max_height;
-    }
-
-    if (resizeIncFlags & PHorzResizeInc)
-	xinc = MAX (xinc, hints->width_inc);
-
-    if (resizeIncFlags & PVertResizeInc)
-	yinc = MAX (yinc, hints->height_inc);
-
-    /* clamp width and height to min and max values */
-    width  = CLAMP (width, min_width, max_width);
-    height = CLAMP (height, min_height, max_height);
-
-    /* shrink to base + N * inc */
-    width  = base_width + FLOOR (width - base_width, xinc);
-    height = base_height + FLOOR (height - base_height, yinc);
-
-    /* constrain aspect ratio, according to:
-     *
-     * min_aspect.x       width      max_aspect.x
-     * ------------  <= -------- <=  -----------
-     * min_aspect.y       height     max_aspect.y
-     */
-    if ((flags & PAspect) && hints->min_aspect.y > 0 && hints->max_aspect.x > 0)
-    {
-	/* Use 64 bit arithmetic to prevent overflow */
-
-	uint64_t min_aspect_x = hints->min_aspect.x;
-	uint64_t min_aspect_y = hints->min_aspect.y;
-	uint64_t max_aspect_x = hints->max_aspect.x;
-	uint64_t max_aspect_y = hints->max_aspect.y;
-	uint64_t delta;
-
-	if (min_aspect_x * height > width * min_aspect_y)
-	{
-	    delta = FLOOR64 (height - width * min_aspect_y / min_aspect_x,
-			     yinc);
-	    if (height - (int) delta >= min_height)
-		height -= delta;
-	    else
-	    {
-		delta = FLOOR64 (height * min_aspect_x / min_aspect_y - width,
-				 xinc);
-		if (width + (int) delta <= max_width)
-		    width += delta;
-	    }
-	}
-
-	if (width * max_aspect_y > max_aspect_x * height)
-	{
-	    delta = FLOOR64 (width - height * max_aspect_x / max_aspect_y,
-			     xinc);
-	    if (width - (int) delta >= min_width)
-		width -= delta;
-	    else
-	    {
-		delta = FLOOR64 (width * min_aspect_y / min_aspect_x - height,
-				 yinc);
-		if (height + (int) delta <= max_height)
-		    height += delta;
-	    }
-	}
-    }
-
-#undef CLAMP
-#undef FLOOR64
-#undef FLOOR
-
-    if (width != oldWidth || height != oldHeight)
-    {
-	*newWidth  = width;
-	*newHeight = height;
-
-	return true;
-    }
-
-    return false;
+static inline int constrainmentFloor (int value, int base)
+{
+    return (value / base) * base;
+}
+
+static inline uint64_t constrainment64Floor (uint64_t value, uint64_t base)
+{
+    return (value / base) * base;
+}
+
+CompSize
+compiz::window::constrainment::constrainToHints (CompWindow       *w,
+						 const CompSize   &size)
+{
+    unsigned int resizeIgnoreHints = 0;
+    unsigned int ignoreHints = 0;
+
+    if (screen->getOption ("ignore_hints_when_maximized"))
+    {
+	if (w->state () & MAXIMIZE_STATE)
+	{
+	    ignoreHints |= PAspect;
+
+	    if (w->state () & CompWindowStateMaximizedHorzMask)
+		resizeIgnoreHints |= PHorzResizeInc;
+
+	    if (w->state () & CompWindowStateMaximizedVertMask)
+		resizeIgnoreHints |= PVertResizeInc;
+	}
+    }
+
+    return constrainToHints (w->sizeHints (), size, ignoreHints, resizeIgnoreHints);
 }
 
 void

=== modified file 'src/window/CMakeLists.txt'
--- src/window/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ src/window/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -1,3 +1,4 @@
 add_subdirectory (geometry)
 add_subdirectory (geometry-saver)
 add_subdirectory (extents)
+add_subdirectory (constrainment)

=== added directory 'src/window/constrainment'
=== added file 'src/window/constrainment/CMakeLists.txt'
--- src/window/constrainment/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/window/constrainment/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -0,0 +1,72 @@
+pkg_check_modules (
+  GLIBMM
+  REQUIRED
+  glibmm-2.4 glib-2.0
+)
+
+INCLUDE_DIRECTORIES (  
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+  
+  ${compiz_SOURCE_DIR}/include
+
+  ${compiz_SOURCE_DIR}/src/point/include
+  ${compiz_SOURCE_DIR}/src/rect/include
+  ${compiz_SOURCE_DIR}/src/window/geometry/include
+  ${compiz_SOURCE_DIR}/src/window/geometry-saver/include  
+  ${Boost_INCLUDE_DIRS}
+  
+  ${GLIBMM_INCLUDE_DIRS}
+)
+
+LINK_DIRECTORIES (${GLIBMM_LIBRARY_DIRS}) 
+
+SET ( 
+  PUBLIC_HEADERS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/core/windowconstrainment.h
+)
+
+SET ( 
+  PRIVATE_HEADERS 
+)
+
+SET( 
+  SRCS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/windowconstrainment.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_window_constrainment STATIC
+  
+  ${SRCS}
+  
+  ${PUBLIC_HEADERS}
+  ${PRIVATE_HEADERS}
+)
+
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+
+SET_TARGET_PROPERTIES(
+  compiz_window_constrainment PROPERTIES
+  PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
+)
+
+INSTALL(
+  TARGETS                                 compiz_window_constrainment
+  RUNTIME             DESTINATION         bin
+  LIBRARY             DESTINATION         lib
+  ARCHIVE             DESTINATION         lib
+  PUBLIC_HEADER       DESTINATION         include/compiz
+)
+
+
+
+TARGET_LINK_LIBRARIES( 
+  compiz_window_constrainment
+  compiz_window_geometry
+  compiz_point
+  compiz_rect
+  
+  ${GLIBMM_LIBRARIES}
+)

=== added directory 'src/window/constrainment/include'
=== added directory 'src/window/constrainment/include/core'
=== added file 'src/window/constrainment/include/core/windowconstrainment.h'
--- src/window/constrainment/include/core/windowconstrainment.h	1970-01-01 00:00:00 +0000
+++ src/window/constrainment/include/core/windowconstrainment.h	2012-01-13 13:20:03 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2008 Dennis Kasprzyk
+ * Copyright © 2007 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ */
+
+#ifndef _COMPWINDOWCONSTRAINMENT_H
+#define _COMPWINDOWCONSTRAINMENT_H
+
+#include <inttypes.h>
+#include <core/size.h>
+#include <core/rect.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <limits>
+
+namespace compiz
+{
+namespace window
+{
+
+namespace constrainment
+{
+const unsigned int PVertResizeInc = (1 << 0);
+const unsigned int PHorzResizeInc = (1 << 1);
+
+CompSize constrainToHints (const XSizeHints &hints,
+			   const CompSize   &size,
+			   unsigned int     ignoreHints,
+			   unsigned int     resizeIgnoreHints);
+}
+
+}
+}
+
+#endif

=== added directory 'src/window/constrainment/src'
=== added file 'src/window/constrainment/src/windowconstrainment.cpp'
--- src/window/constrainment/src/windowconstrainment.cpp	1970-01-01 00:00:00 +0000
+++ src/window/constrainment/src/windowconstrainment.cpp	2012-01-13 13:20:03 +0000
@@ -0,0 +1,161 @@
+/*
+ * Copyright © 2005 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Novell, Inc. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Novell, Inc. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: David Reveman <[e-mail]>
+ */
+
+#include <core/windowconstrainment.h>
+
+static inline int constrainmentFloor (int value, int base)
+{
+    return (value / base) * base;
+}
+
+static inline uint64_t constrainment64Floor (uint64_t value, uint64_t base)
+{
+    return (value / base) * base;
+}
+
+static inline float constrainmentClamp(float x, float a, float b)
+{
+    return x < a ? a : (x > b ? b : x);
+}
+
+CompSize
+compiz::window::constrainment::constrainToHints (const XSizeHints &hints,
+						 const CompSize   &size,
+						 unsigned int     ignoreHints,
+					         unsigned int     resizeIgnoreHints)
+{
+    int              width = size.width ();
+    int              height = size.height ();
+    int		     min_width = 1;
+    int		     min_height = 1;
+    int		     base_width = 1;
+    int		     base_height = 1;
+    int		     xinc = 1;
+    int		     yinc = 1;
+    int		     max_width = std::numeric_limits <short>::max ();
+    int		     max_height = std::numeric_limits <short>::max ();
+    long	     flags = hints.flags & ~ignoreHints;
+    long	     resizeIncFlags = (flags & PResizeInc) ? (~resizeIgnoreHints) : 0;
+
+    /* Ater gdk_window_constrain_size(), which is partially borrowed from fvwm.
+     *
+     * Copyright 1993, Robert Nation
+     *     You may use this code for any purpose, as long as the original
+     *     copyright remains in the source code and all documentation
+     *
+     * which in turn borrows parts of the algorithm from uwm
+     */
+
+    if ((flags & PBaseSize) && (flags & PMinSize))
+    {
+	base_width = std::max (1, hints.base_width);
+	base_height = std::max (1, hints.base_height);
+	min_width = std::max (1, hints.min_width);
+	min_height = std::max (1, hints.min_height);
+    }
+    else if (flags & PBaseSize)
+    {
+	base_width = std::max (1, hints.base_width);
+	base_height = std::max (1, hints.base_height);
+	min_width = std::max (1, hints.base_width);
+	min_height = std::max (1, hints.base_height);
+    }
+    else if (flags & PMinSize)
+    {
+	base_width = std::max (1, hints.min_width);
+	base_height = std::max (1, hints.min_height);
+	min_width = std::max (1, hints.min_width);
+	min_height = std::max (1, hints.min_height);
+    }
+
+    if (flags & PMaxSize)
+    {
+	max_width = std::max (1, hints.max_width);
+	max_height = std::max (1, hints.max_height);
+    }
+
+    if (resizeIncFlags & PHorzResizeInc)
+	xinc = std::max (xinc, hints.width_inc);
+
+    if (resizeIncFlags & PVertResizeInc)
+	yinc = std::max (yinc, hints.height_inc);
+
+    /* clamp width and height to min and max values */
+    width  = constrainmentClamp (width, min_width, max_width);
+    height = constrainmentClamp (height, min_height, max_height);
+
+    /* shrink to base + N * inc */
+    width  = base_width + constrainmentFloor (width - base_width, xinc);
+    height = base_height + constrainmentFloor (height - base_height, yinc);
+
+    /* constrain aspect ratio, according to:
+     *
+     * min_aspect.x       width      max_aspect.x
+     * ------------  <= -------- <=  -----------
+     * min_aspect.y       height     max_aspect.y
+     */
+    if ((flags & PAspect) && hints.min_aspect.y > 0 && hints.max_aspect.x > 0)
+    {
+	/* Use 64 bit arithmetic to prevent overflow */
+
+	uint64_t min_aspect_x = hints.min_aspect.x;
+	uint64_t min_aspect_y = hints.min_aspect.y;
+	uint64_t max_aspect_x = hints.max_aspect.x;
+	uint64_t max_aspect_y = hints.max_aspect.y;
+	uint64_t delta;
+
+	if (min_aspect_x * height > width * min_aspect_y)
+	{
+	    delta = constrainment64Floor (height - width * min_aspect_y / min_aspect_x,
+			     yinc);
+	    if (height - (int) delta >= min_height)
+		height -= delta;
+	    else
+	    {
+		delta = constrainment64Floor (height * min_aspect_x / min_aspect_y - width,
+				 xinc);
+		if (width + (int) delta <= max_width)
+		    width += delta;
+	    }
+	}
+
+	if (width * max_aspect_y > max_aspect_x * height)
+	{
+	    delta = constrainment64Floor (width - height * max_aspect_x / max_aspect_y,
+			     xinc);
+	    if (width - (int) delta >= min_width)
+		width -= delta;
+	    else
+	    {
+		delta = constrainment64Floor (width * min_aspect_y / min_aspect_x - height,
+				 yinc);
+		if (height + (int) delta <= max_height)
+		    height += delta;
+	    }
+	}
+    }
+
+    return CompSize (width, height);
+}

=== added directory 'src/window/constrainment/tests'
=== added file 'src/window/constrainment/tests/CMakeLists.txt'
--- src/window/constrainment/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/window/constrainment/tests/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -0,0 +1,19 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+add_library (compiz_window_constrainment_test
+             ${CMAKE_CURRENT_SOURCE_DIR}/test-window-constrainment.cpp)
+
+add_executable (compiz_test_window_constrainment_to_hints
+                ${CMAKE_CURRENT_SOURCE_DIR}/to-hints/src/test-window-constrainment-to-hints.cpp
+		${compiz_SOURCE_DIR}/src/size.cpp)
+
+target_link_libraries (compiz_test_window_constrainment_to_hints
+                       compiz_window_constrainment_test
+                       compiz_window_constrainment 
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread. 
+                       )
+
+add_test (compiz_window_constrainment_to_hints compiz_test_window_constrainment_to_hints)

=== added file 'src/window/constrainment/tests/test-window-constrainment.cpp'
--- src/window/constrainment/tests/test-window-constrainment.cpp	1970-01-01 00:00:00 +0000
+++ src/window/constrainment/tests/test-window-constrainment.cpp	2012-01-13 13:20:03 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include "test-window-constrainment.h"
+
+CompWindowConstrainmentTest::CompWindowConstrainmentTest ()
+{
+}
+
+CompWindowConstrainmentTest::~CompWindowConstrainmentTest ()
+{
+}

=== added file 'src/window/constrainment/tests/test-window-constrainment.h'
--- src/window/constrainment/tests/test-window-constrainment.h	1970-01-01 00:00:00 +0000
+++ src/window/constrainment/tests/test-window-constrainment.h	2012-01-13 13:20:03 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#ifndef _COMPIZ_TEST_WINDOW_CONSTRAINMENT_H
+#define _COMPIZ_TEST_WINDOW_CONSTRAINMENT_H
+
+#include <gtest/gtest.h>
+#include <core/windowconstrainment.h>
+#include <core/windowgeometry.h>
+#include <iostream>
+#include <boost/bind.hpp>
+
+class CompWindowConstrainmentTest : public ::testing::Test
+{
+public:
+
+    CompWindowConstrainmentTest ();
+    virtual ~CompWindowConstrainmentTest ();
+};
+
+#endif

=== added directory 'src/window/constrainment/tests/to-hints'
=== added directory 'src/window/constrainment/tests/to-hints/src'
=== added file 'src/window/constrainment/tests/to-hints/src/test-window-constrainment-to-hints.cpp'
--- src/window/constrainment/tests/to-hints/src/test-window-constrainment-to-hints.cpp	1970-01-01 00:00:00 +0000
+++ src/window/constrainment/tests/to-hints/src/test-window-constrainment-to-hints.cpp	2012-01-13 13:20:03 +0000
@@ -0,0 +1,210 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include "test-window-constrainment.h"
+#include <cstring>
+
+class CompWindowConstrainmentTestToHints :
+    public CompWindowConstrainmentTest
+{
+public:
+
+    CompWindowConstrainmentTestToHints ();
+    virtual ~CompWindowConstrainmentTestToHints ();
+};
+
+CompWindowConstrainmentTestToHints::CompWindowConstrainmentTestToHints ()
+{
+}
+
+CompWindowConstrainmentTestToHints::~CompWindowConstrainmentTestToHints ()
+{
+}
+
+TEST_F (CompWindowConstrainmentTestToHints, ToHints)
+{
+    /* No hints, size is the same */
+    XSizeHints hints;
+    CompSize   size (1000, 1000);
+
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (1000, 1000));
+
+    /* Minimum size specified, constrain to minimum size */
+    size = CompSize (100, 100);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PMinSize;
+    hints.min_width = 500;
+    hints.min_height = 500;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (500, 500));
+
+    /* Base size specified, constrain to base size as minimum size */
+    size = CompSize (100, 100);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PBaseSize;
+    hints.base_width = 500;
+    hints.base_height = 500;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (500, 500));
+
+    /* Minimum and base size specified, constrain to min size as minimum size */
+    size = CompSize (100, 100);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PBaseSize | PMinSize;
+    hints.base_width = 700;
+    hints.base_height = 700;
+    hints.min_width = 500;
+    hints.min_height = 500;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (500, 500));
+
+    /* Maximum size specified, constrain to minimum size */
+    size = CompSize (1000, 1000);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PMaxSize;
+    hints.max_width = 500;
+    hints.max_height = 500;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (500, 500));
+
+    /* Resize flags specified, constrain to closest low step of
+     * increments for size specified */
+    size = CompSize (1002, 1002);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PBaseSize | PResizeInc;
+    hints.base_width = 500;
+    hints.base_height = 500;
+    hints.width_inc = 5;
+    hints.height_inc = 5;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (1000, 1000));
+
+    /* Resize flags specified, constrain to closest low step of
+     * increments for size specified */
+    size = CompSize (1004, 1004);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PBaseSize | PResizeInc;
+    hints.base_width = 500;
+    hints.base_height = 500;
+    hints.width_inc = 5;
+    hints.height_inc = 5;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (1000, 1000));
+
+    /* Resize flags specified, constrain to closest low step of
+     * increments for size specified */
+    size = CompSize (1006, 1006);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PBaseSize | PResizeInc;
+    hints.base_width = 500;
+    hints.base_height = 500;
+    hints.width_inc = 5;
+    hints.height_inc = 5;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (1005, 1005));
+
+    /* Don't require constrainment on width */
+    size = CompSize (1002, 1002);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PBaseSize | PResizeInc;
+    hints.base_width = 500;
+    hints.base_height = 500;
+    hints.width_inc = 5;
+    hints.height_inc = 5;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, compiz::window::constrainment::PHorzResizeInc);
+
+    EXPECT_EQ (size, CompSize (1002, 1000));
+
+    /* Don't require constrainment on height */
+    size = CompSize (1002, 1002);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PBaseSize | PResizeInc;
+    hints.base_width = 500;
+    hints.base_height = 500;
+    hints.width_inc = 5;
+    hints.height_inc = 5;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, compiz::window::constrainment::PVertResizeInc);
+
+    EXPECT_EQ (size, CompSize (1000, 1002));
+
+    /* Aspect ratios - don't allow sizes less than 1:2 or more than 2:5
+     * clamping to the largest size */
+    size = CompSize (4000, 5000);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PAspect;
+    hints.min_aspect.x = 1;
+    hints.min_aspect.y = 2;
+    hints.max_aspect.x = 2;
+    hints.max_aspect.y = 5;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (2000, 5000));
+
+    /* Aspect ratios - don't allow sizes less than 1:2 or more than 2:5
+     * clamping to the largest size */
+    size = CompSize (12, 20);
+    memset (&hints, 0, sizeof (XSizeHints));
+
+    hints.flags |= PAspect;
+    hints.min_aspect.x = 1;
+    hints.min_aspect.y = 2;
+    hints.max_aspect.x = 2;
+    hints.max_aspect.y = 5;
+
+    size = compiz::window::constrainment::constrainToHints (hints, size, 0, 0);
+
+    EXPECT_EQ (size, CompSize (8, 20));
+}

=== modified file 'src/window/extents/CMakeLists.txt'
--- src/window/extents/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ src/window/extents/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -47,6 +47,7 @@
 SET_TARGET_PROPERTIES(
   compiz_window_extents PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/window/geometry-saver/CMakeLists.txt'
--- src/window/geometry-saver/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ src/window/geometry-saver/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -49,6 +49,7 @@
 SET_TARGET_PROPERTIES(
   compiz_window_geometry_saver PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(

=== modified file 'src/window/geometry/CMakeLists.txt'
--- src/window/geometry/CMakeLists.txt	2012-01-13 13:20:02 +0000
+++ src/window/geometry/CMakeLists.txt	2012-01-13 13:20:03 +0000
@@ -47,6 +47,7 @@
 SET_TARGET_PROPERTIES(
   compiz_window_geometry PROPERTIES
   PUBLIC_HEADER "${PUBLIC_HEADERS}"
+  COMPILE_FLAGS "-fPIC"
 )
 
 INSTALL(