Merge lp:~smspillaz/compiz-core/compiz-core.tests_915950 into lp:compiz-core/0.9.5

[Sam Spilsbury]

Tests that smart placement does not put windows offscreen on two different sized monitors

[Sam Spilsbury (smspillaz)]

Whoops, missing a commit here

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Or rather, there's a useless file here.

[Daniel van Vugt (vanvugt)]

Maybe it's just me, but I'm concerned about the amount of core code being rewritten here (and wasn't reviewed). If it were up to me I wouldn't modify so much core code so close to release. I don't think all the changes are relevant to writing test cases either.

[Daniel van Vugt (vanvugt)]

Sam reverted the merge. Needs review again.

[Sam Spilsbury (smspillaz)]

Code was unintentionally pushed to trunk. thats now reverted.

As for this change - all it does is add an interface for a placeable object. the diff is large because things moved around etc

[Alan Griffiths (alan-griffiths)]

This *looks* OK, but like Daniel says it looks like several (sequential) changes overlayed on each other which makes it hard to validate.

I'd prefer to see separate commits for refactoring (moving/renaming stuff) and functional changes (making it work). (But I'm as guilty of mixing the two.)

review: Approve

[Sam Spilsbury (smspillaz)]

review: Approve

=== modified file 'plugins/place/CMakeLists.txt'
--- plugins/place/CMakeLists.txt	2012-01-20 06:27:10 +0000
+++ plugins/place/CMakeLists.txt	2012-01-30 18:23:23 +0000
@@ -4,7 +4,10 @@
 
 include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/constrain-to-workarea/include/)
 include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/screen-size-change/include/)
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/smart/include/)
 
 add_subdirectory (src/constrain-to-workarea)
 add_subdirectory (src/screen-size-change)
-compiz_plugin (place LIBRARIES compiz_place_constrain_to_workarea compiz_place_screen_size_change)
+add_subdirectory (src/smart)
+
+compiz_plugin (place LIBRARIES compiz_place_constrain_to_workarea compiz_place_screen_size_change compiz_place_smart)

=== modified file 'plugins/place/src/place.cpp'
--- plugins/place/src/place.cpp	2012-01-25 09:20:47 +0000
+++ plugins/place/src/place.cpp	2012-01-30 18:23:23 +0000
@@ -65,7 +65,6 @@
     return l;
 }
 
-
 void
 PlaceScreen::doHandleScreenSizeChange (int  newWidth,
 				       int  newHeight)
@@ -101,12 +100,31 @@
     return screen->getWorkareaForOutput (screen->outputDeviceForGeometry (g));
 }
 
+const CompRect &
+PlaceWindow::getWorkarea () const
+{
+    return getWorkarea (window->serverGeometry ());
+}
+
 const compiz::window::extents::Extents &
 PlaceWindow::getExtents () const
 {
     return window->border ();
 }
 
+unsigned int
+PlaceWindow::getState () const
+{
+    unsigned int state = 0;
+
+    if (window->state () & CompWindowStateAboveMask)
+	state |= compiz::place::WindowAbove;
+    if (window->state () & CompWindowStateBelowMask)
+	state |= compiz::place::WindowBelow;
+
+    return state;
+}
+
 void
 PlaceWindow::applyGeometry (compiz::window::Geometry &ng,
 			    compiz::window::Geometry &og)
@@ -224,42 +242,42 @@
 /* sort functions */
 
 static bool
-compareLeftmost (CompWindow *a,
-		 CompWindow *b)
+compareLeftmost (compiz::place::Placeable *a,
+		 compiz::place::Placeable *b)
 {
     int ax, bx;
 
-    ax = a->serverX () - a->border ().left;
-    bx = b->serverX () - b->border ().left;
+    ax = a->geometry ().x () - a->extents ().left;
+    bx = b->geometry ().x () - a->extents ().left;
 
     return (ax <= bx);
 }
 
 static bool
-compareTopmost (CompWindow *a,
-		CompWindow *b)
+compareTopmost (compiz::place::Placeable *a,
+		compiz::place::Placeable *b)
 {
     int ay, by;
 
-    ay = a->serverY () - a->border ().top;
-    by = b->serverY () - b->border ().top;
+    ay = a->geometry ().y () - a->extents ().top;
+    by = b->geometry ().y () - a->extents ().top;
 
     return (ay <= by);
 }
 
 static bool
-compareNorthWestCorner (CompWindow *a,
-			CompWindow *b)
+compareNorthWestCorner (compiz::place::Placeable *a,
+			compiz::place::Placeable *b)
 {
     int fromOriginA;
     int fromOriginB;
     int ax, ay, bx, by;
 
-    ax = a->serverX () - a->border ().left;
-    ay = a->serverY () - a->border ().top;
+    ax = a->geometry ().x () - a->extents ().left;
+    bx = b->geometry ().x () - a->extents ().left;
 
-    bx = b->serverX () - b->border ().left;
-    by = b->serverY () - b->border ().top;
+    ay = a->geometry ().y () - a->extents ().top;
+    by = b->geometry ().y () - a->extents ().top;
 
     /* probably there's a fast good-enough-guess we could use here. */
     fromOriginA = sqrt (ax * ax + ay * ay);
@@ -585,6 +603,17 @@
 
     if (strategy == PlaceOnly || strategy == PlaceAndConstrain)
     {
+	/* Construct list of placeables */
+	compiz::place::Placeable::Vector placeables;
+
+	foreach (CompWindow *w, screen->windows ())
+	{
+	    PLACE_WINDOW (w);
+
+	    if (windowIsPlaceRelevant (w))
+		placeables.push_back (static_cast <compiz::place::Placeable *> (pw));
+	}
+
 	switch (mode) {
 	    case PlaceOptions::ModeCascade:
 	    placeCascade (workArea, pos);
@@ -602,7 +631,7 @@
 	    sendMaximizationRequest ();
 	    break;
 	case PlaceOptions::ModeSmart:
-	    placeSmart (workArea, pos);
+	    placeSmart (pos, placeables);
 	    break;
 	}
 
@@ -650,7 +679,7 @@
 PlaceWindow::placeCascade (const CompRect &workArea,
 			   CompPoint      &pos)
 {
-    CompWindowList windows;
+    Placeable::Vector placeables;
 
     /* Find windows that matter (not minimized, on same workspace
      * as placed window, may be shaded - if shaded we pretend it isn't
@@ -671,15 +700,15 @@
 	    w->serverY () + w->serverGeometry ().height () <= workArea.y ())
 	    continue;
 
-	windows.push_back (w);
+	placeables.push_back (static_cast <Placeable *> (PlaceWindow::get (w)));
     }
 
-    if (!cascadeFindFirstFit (windows, workArea, pos))
+    if (!cascadeFindFirstFit (placeables, workArea, pos))
     {
 	/* if the window wasn't placed at the origin of screen,
 	 * cascade it onto the current screen
 	 */
-	cascadeFindNext (windows, workArea, pos);
+	cascadeFindNext (placeables, workArea, pos);
     }
 }
 
@@ -727,201 +756,13 @@
 	placeCentered (workArea, pos);
 }
 
-
-/* overlap types */
-#define NONE    0
-#define H_WRONG -1
-#define W_WRONG -2
+using namespace compiz::place;
 
 void
-PlaceWindow::placeSmart (const CompRect &workArea,
-			 CompPoint      &pos)
+PlaceWindow::placeSmart (CompPoint			&pos,
+			 const compiz::place::Placeable::Vector &placeables)
 {
-    /*
-     * SmartPlacement by Cristian Tibirna ([e-mail])
-     * adapted for kwm (16-19jan98) and for kwin (16Nov1999) using (with
-     * permission) ideas from fvwm, authored by
-     * Anthony Martin ([e-mail]).
-     * Xinerama supported added by Balaji Ramani ([e-mail])
-     * with ideas from xfce.
-     * adapted for Compiz by Bellegarde Cedric (gnumdk(at)gmail.com)
-     */
-    int overlap, minOverlap = 0;
-    int xOptimal, yOptimal;
-    int possible;
-
-    /* temp coords */
-    int cxl, cxr, cyt, cyb;
-    /* temp coords */
-    int xl,  xr,  yt,  yb;
-    /* temp holder */
-    int basket;
-    /* CT lame flag. Don't like it. What else would do? */
-    bool firstPass = true;
-
-    /* get the maximum allowed windows space */
-    int xTmp = workArea.x ();
-    int yTmp = workArea.y ();
-
-    /* client gabarit */
-    int cw = window->serverWidth () - 1;
-    int ch = window->serverHeight () - 1;
-
-    xOptimal = xTmp;
-    yOptimal = yTmp;
-
-    /* loop over possible positions */
-    do
-    {
-	/* test if enough room in x and y directions */
-	if (yTmp + ch > workArea.bottom () && ch < workArea.height ())
-	    overlap = H_WRONG; /* this throws the algorithm to an exit */
-	else if (xTmp + cw > workArea.right ())
-	    overlap = W_WRONG;
-	else
-	{
-	    overlap = NONE; /* initialize */
-
-	    cxl = xTmp;
-	    cxr = xTmp + cw;
-	    cyt = yTmp;
-	    cyb = yTmp + ch;
-
-	    foreach (CompWindow *w, screen->windows ())
-	    {
-		if (!windowIsPlaceRelevant (w))
-		    continue;
-
-		xl = w->serverX () - w->border ().left;
-		yt = w->serverY () - w->border ().top;
-		xr = w->serverX () + w->serverWidth () +
-		     w->border ().right +
-		     w->serverGeometry ().border () * 2;
-		yb = w->serverY () + w->serverHeight () +
-		     w->border ().bottom +
-		     w->serverGeometry ().border () * 2;
-
-		/* if windows overlap, calc the overall overlapping */
-		if (cxl < xr && cxr > xl && cyt < yb && cyb > yt)
-		{
-		    xl = MAX (cxl, xl);
-		    xr = MIN (cxr, xr);
-		    yt = MAX (cyt, yt);
-		    yb = MIN (cyb, yb);
-
-		    if (w->state () & CompWindowStateAboveMask)
-			overlap += 16 * (xr - xl) * (yb - yt);
-		    else if (w->state () & CompWindowStateBelowMask)
-			overlap += 0;
-		    else
-			overlap += (xr - xl) * (yb - yt);
-		}
-	    }
-	}
-
-	/* CT first time we get no overlap we stop */
-	if (overlap == NONE)
-	{
-	    xOptimal = xTmp;
-	    yOptimal = yTmp;
-	    break;
-	}
-
-	if (firstPass)
-	{
-	    firstPass  = false;
-	    minOverlap = overlap;
-	}
-	/* CT save the best position and the minimum overlap up to now */
-	else if (overlap >= NONE && overlap < minOverlap)
-	{
-	    minOverlap = overlap;
-	    xOptimal = xTmp;
-	    yOptimal = yTmp;
-	}
-
-	/* really need to loop? test if there's any overlap */
-	if (overlap > NONE)
-	{
-	    possible = workArea.right ();
-
-	    if (possible - cw > xTmp)
-		possible -= cw;
-
-	    /* compare to the position of each client on the same desk */
-	    foreach (CompWindow *w, screen->windows ())
-	    {
-		if (!windowIsPlaceRelevant (w))
-		    continue;
-
-		xl = w->serverX () - w->border ().left;
-		yt = w->serverY () - w->border ().top;
-		xr = w->serverX () + w->serverWidth () +
-		     w->border ().right +
-		     w->serverGeometry ().border () * 2;
-		yb = w->serverY () + w->serverHeight () +
-		     w->border ().bottom +
-		     w->serverGeometry ().border () * 2;
-
-		/* if not enough room above or under the current
-		 * client determine the first non-overlapped x position
-		 */
-		if (yTmp < yb && yt < ch + yTmp)
-		{
-		    if (xr > xTmp && possible > xr)
-			possible = xr;
-
-		    basket = xl - cw;
-		    if (basket > xTmp && possible > basket)
-			possible = basket;
-		}
-	    }
-	    xTmp = possible;
-	}
-	/* else ==> not enough x dimension (overlap was wrong on horizontal) */
-	else if (overlap == W_WRONG)
-	{
-	    xTmp     = workArea.x ();
-	    possible = workArea.bottom ();
-
-	    if (possible - ch > yTmp)
-		possible -= ch;
-
-	    /* test the position of each window on the desk */
-	    foreach (CompWindow *w, screen->windows ())
-	    {
-		if (!windowIsPlaceRelevant (w))
-		    continue;
-
-		xl = w->serverX () - w->border ().left;
-		yt = w->serverY () - w->border ().top;
-		xr = w->serverX () + w->serverWidth () +
-		     w->border ().right +
-		     w->serverGeometry ().border () * 2;
-		yb = w->serverY () + w->serverHeight () +
-		     w->border ().bottom +
-		     w->serverGeometry ().border () * 2;
-
-		/* if not enough room to the left or right of the current
-		 * client determine the first non-overlapped y position
-		 */
-		if (yb > yTmp && possible > yb)
-		    possible = yb;
-
-		basket = yt - ch;
-		if (basket > yTmp && possible > basket)
-		    possible = basket;
-	    }
-	    yTmp = possible;
-	}
-    }
-    while (overlap != NONE && overlap != H_WRONG && yTmp < workArea.bottom ());
-
-    if (ch >= workArea.height ())
-	yOptimal = workArea.y ();
-
-    pos.setX (xOptimal + window->border ().left);
-    pos.setY (yOptimal + window->border ().top);
+    compiz::place::smart (this, pos, placeables);
 }
 
 static void
@@ -945,32 +786,22 @@
 
 static bool
 rectOverlapsWindow (const CompRect       &rect,
-		    const CompWindowList &windows)
+		    const compiz::place::Placeable::Vector &placeables)
 {
     CompRect dest;
 
-    foreach (CompWindow *other, windows)
+    foreach (compiz::place::Placeable *other, placeables)
     {
 	CompRect intersect;
+	CompRect sbr = other->geometry ();
+	sbr.setLeft (sbr.left () - other->extents ().left);
+	sbr.setRight (sbr.right () + other->extents ().right);
+	sbr.setTop (sbr.top () - other->extents ().top);
+	sbr.setBottom (sbr.bottom () - other->extents ().bottom);
 
-	switch (other->type ()) {
-	case CompWindowTypeDockMask:
-	case CompWindowTypeSplashMask:
-	case CompWindowTypeDesktopMask:
-	case CompWindowTypeDialogMask:
-	case CompWindowTypeModalDialogMask:
-	case CompWindowTypeFullscreenMask:
-	case CompWindowTypeUnknownMask:
-	    break;
-	case CompWindowTypeNormalMask:
-	case CompWindowTypeUtilMask:
-	case CompWindowTypeToolbarMask:
-	case CompWindowTypeMenuMask:
-	    intersect = rect & other->serverBorderRect ();
-	    if (!intersect.isEmpty ())
-		return true;
-	    break;
-	}
+	intersect = rect & sbr;
+	if (!intersect.isEmpty ())
+	    return true;
     }
 
     return false;
@@ -985,7 +816,7 @@
  * don't want to create a 1x1 Emacs.
  */
 bool
-PlaceWindow::cascadeFindFirstFit (const CompWindowList &windows,
+PlaceWindow::cascadeFindFirstFit (const Placeable::Vector &placeables,
 				  const CompRect       &workArea,
 				  CompPoint            &pos)
 {
@@ -997,49 +828,59 @@
      * existing window in each of those cases.
      */
     bool           retval = false;
-    CompWindowList belowSorted, rightSorted;
-    CompRect       rect;
+    Placeable::Vector belowSorted, rightSorted;
 
     /* Below each window */
-    belowSorted = windows;
-    belowSorted.sort (compareLeftmost);
-    belowSorted.sort (compareTopmost);
+    belowSorted = placeables;
+    std::sort (belowSorted.begin (), belowSorted.end (), compareLeftmost);
+    std::sort (belowSorted.begin (), belowSorted.end (), compareTopmost);
 
     /* To the right of each window */
-    rightSorted = windows;
-    rightSorted.sort (compareTopmost);
-    rightSorted.sort (compareLeftmost);
-
-    rect = window->serverBorderRect ();
+    rightSorted = placeables;
+    std::sort (belowSorted.begin (), belowSorted.end (), compareTopmost);
+    std::sort (belowSorted.begin (), belowSorted.end (), compareLeftmost);
+
+    CompRect rect = this->geometry ();
+
+    rect.setLeft (rect.left () - this->extents ().left);
+    rect.setRight (rect.right () + this->extents ().right);
+    rect.setTop (rect.top () - this->extents ().top);
+    rect.setBottom (rect.bottom () - this->extents ().bottom);
+
     centerTileRectInArea (rect, workArea);
 
-    if (workArea.contains (rect) && !rectOverlapsWindow (rect, windows))
+    if (workArea.contains (rect) && !rectOverlapsWindow (rect, placeables))
     {
-	pos.setX (rect.x () + window->border ().left);
-	pos.setY (rect.y () + window->border ().top);
+	pos.setX (rect.x () + this->extents ().left);
+	pos.setY (rect.y () + this->extents ().top);
 	retval = true;
     }
 
     if (!retval)
     {
 	/* try below each window */
-	foreach (CompWindow *w, belowSorted)
+	foreach (Placeable *p, belowSorted)
 	{
 	    CompRect outerRect;
 
 	    if (retval)
 		break;
 
-	    outerRect = w->serverBorderRect ();
-
-	    rect.setX (outerRect.x ());
-	    rect.setY (outerRect.bottom ());
+	    outerRect = p->geometry ();
+
+	    outerRect.setLeft (rect.left () - this->extents ().left);
+	    outerRect.setRight (rect.right () + this->extents ().right);
+	    outerRect.setTop (rect.top () - this->extents ().top);
+	    outerRect.setBottom (rect.bottom () - this->extents ().bottom);
+
+	    outerRect.setX (outerRect.x ());
+	    outerRect.setY (outerRect.bottom ());
 
 	    if (workArea.contains (rect) &&
 		!rectOverlapsWindow (rect, belowSorted))
 	    {
-		pos.setX (rect.x () + window->border ().left);
-		pos.setY (rect.y () + window->border ().top);
+		pos.setX (rect.x () + this->extents ().left);
+		pos.setY (rect.y () + this->extents ().top);
 		retval = true;
 	    }
 	}
@@ -1048,23 +889,28 @@
     if (!retval)
     {
 	/* try to the right of each window */
-	foreach (CompWindow *w, rightSorted)
+	foreach (Placeable *p, rightSorted)
 	{
 	    CompRect outerRect;
 
 	    if (retval)
 		break;
 
-	    outerRect = w->serverBorderRect ();
-
-	    rect.setX (outerRect.right ());
-	    rect.setY (outerRect.y ());
+	    outerRect = p->geometry ();
+
+	    outerRect.setLeft (rect.left () - this->extents ().left);
+	    outerRect.setRight (rect.right () + this->extents ().right);
+	    outerRect.setTop (rect.top () - this->extents ().top);
+	    outerRect.setBottom (rect.bottom () - this->extents ().bottom);
+
+	    outerRect.setX (outerRect.right ());
+	    outerRect.setY (outerRect.y ());
 
 	    if (workArea.contains (rect) &&
 		!rectOverlapsWindow (rect, rightSorted))
 	    {
-		pos.setX (rect.x () + w->border ().left);
-		pos.setY (rect.y () + w->border ().top);
+		pos.setX (rect.x () + this->extents ().left);
+		pos.setY (rect.y () + this->extents ().top);
 		retval = true;
 	    }
 	}
@@ -1074,19 +920,19 @@
 }
 
 void
-PlaceWindow::cascadeFindNext (const CompWindowList &windows,
-			      const CompRect       &workArea,
-			      CompPoint            &pos)
+PlaceWindow::cascadeFindNext (const Placeable::Vector &placeables,
+			      const CompRect	      &workArea,
+			      CompPoint		      &pos)
 {
-    CompWindowList           sorted;
-    CompWindowList::iterator iter;
-    int                      cascadeX, cascadeY;
-    int                      xThreshold, yThreshold;
-    int                      winWidth, winHeight;
-    int                      cascadeStage;
+    Placeable::Vector           sorted;
+    Placeable::Vector::iterator iter;
+    int                         cascadeX, cascadeY;
+    int                         xThreshold, yThreshold;
+    int                         winWidth, winHeight;
+    int                         cascadeStage;
 
-    sorted = windows;
-    sorted.sort (compareNorthWestCorner);
+    sorted = placeables;
+    std::sort (sorted.begin (), sorted.end (), compareNorthWestCorner);
 
     /* This is a "fuzzy" cascade algorithm.
      * For each window in the list, we find where we'd cascade a
@@ -1099,8 +945,8 @@
      */
 #define CASCADE_FUZZ 15
 
-    xThreshold = MAX (window->border ().left, CASCADE_FUZZ);
-    yThreshold = MAX (window->border ().top, CASCADE_FUZZ);
+    xThreshold = MAX (this->extents ().left, CASCADE_FUZZ);
+    yThreshold = MAX (this->extents ().top, CASCADE_FUZZ);
 
     /* Find furthest-SE origin of all workspaces.
      * cascade_x, cascade_y are the target position
@@ -1118,12 +964,12 @@
     cascadeStage = 0;
     for (iter = sorted.begin (); iter != sorted.end (); iter++)
     {
-	CompWindow *w = *iter;
+	Placeable  *p = *iter;
 	int        wx, wy;
 
 	/* we want frame position, not window position */
-	wx = w->serverX () - w->border ().left;
-	wy = w->serverY () - w->border ().top;
+	wx = p->geometry ().x () - p->extents ().left;
+	wy = p->geometry ().y () - p->extents ().top;
 
 	if (abs (wx - cascadeX) < xThreshold &&
 	    abs (wy - cascadeY) < yThreshold)
@@ -1132,8 +978,8 @@
 	     * point. The new window frame should go at the origin
 	     * of the client window we're stacking above.
 	     */
-	    wx = cascadeX = w->serverX ();
-	    wy = cascadeY = w->serverY ();
+	    wx = cascadeX = p->geometry ().x ();
+	    wy = cascadeY = p->geometry ().y ();
 
 	    /* If we go off the screen, start over with a new cascade */
 	    if ((cascadeX + winWidth > workArea.right ()) ||
@@ -1174,8 +1020,8 @@
      */
 
     /* Convert coords to position of window, not position of frame. */
-    pos.setX (cascadeX + window->border ().left);
-    pos.setY (cascadeY + window->border ().top);
+    pos.setX (cascadeX + this->extents ().left);
+    pos.setY (cascadeY + this->extents ().top);
 }
 
 bool

=== modified file 'plugins/place/src/place.h'
--- plugins/place/src/place.h	2012-01-21 17:16:07 +0000
+++ plugins/place/src/place.h	2012-01-30 18:23:23 +0000
@@ -31,6 +31,7 @@
 
 #include "place_options.h"
 #include "screen-size-change.h"
+#include "smart.h"
 
 namespace compiz
 {
@@ -39,7 +40,6 @@
     {
 
 	CompWindowList collectStrutWindows (const CompWindowList &allWindows);
-
     }
 
 }
@@ -74,6 +74,7 @@
 class PlaceWindow :
     public PluginClassHandler<PlaceWindow, CompWindow>,
     public compiz::place::ScreenSizeChangeObject,
+    public compiz::place::Placeable,
     public WindowInterface
 {
     public:
@@ -101,8 +102,11 @@
 	const compiz::window::Geometry & getGeometry () const;
 	const CompPoint & getViewport () const;
 	const CompRect & getWorkarea (const compiz::window::Geometry &g) const;
+	const CompRect & getWorkarea () const;
 	const compiz::window::extents::Extents & getExtents () const;
 
+	unsigned int getState () const;
+
     private:
 	typedef enum {
 	    NoPlacement = 0,
@@ -129,12 +133,12 @@
 	void placeCentered (const CompRect& workArea, CompPoint& pos);
 	void placeRandom (const CompRect& workArea, CompPoint& pos);
 	void placePointer (const CompRect& workArea, CompPoint& pos);
-	void placeSmart (const CompRect& workArea, CompPoint& pos);
+	void placeSmart (CompPoint& pos, const compiz::place::Placeable::Vector &);
 
-	bool cascadeFindFirstFit (const CompWindowList& windows,
+	bool cascadeFindFirstFit (const Placeable::Vector &placeabless,
 				  const CompRect& workArea,
 				  CompPoint &pos);
-	void cascadeFindNext (const CompWindowList& windows,
+	void cascadeFindNext (const Placeable::Vector &placeables,
 			      const CompRect& workArea,
 			      CompPoint &pos);
 

=== added directory 'plugins/place/src/smart'
=== added file 'plugins/place/src/smart/CMakeLists.txt'
--- plugins/place/src/smart/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/place/src/smart/CMakeLists.txt	2012-01-30 18:23:23 +0000
@@ -0,0 +1,62 @@
+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}/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/smart.h
+)
+
+SET( 
+  SRCS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/smart.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_place_smart STATIC
+  
+  ${SRCS}
+  
+  ${PUBLIC_HEADERS}
+  ${PRIVATE_HEADERS}
+)
+
+if (COMPIZ_BUILD_TESTING)
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+endif (COMPIZ_BUILD_TESTING)
+
+SET_TARGET_PROPERTIES(
+  compiz_place_smart PROPERTIES
+  PUBLIC_HEADER "${PUBLIC_HEADERS}"
+)
+
+TARGET_LINK_LIBRARIES(
+  compiz_place_smart
+
+  compiz_core
+  ${GLIBMM_LIBRARIES}
+)

=== added directory 'plugins/place/src/smart/include'
=== added file 'plugins/place/src/smart/include/smart.h'
--- plugins/place/src/smart/include/smart.h	1970-01-01 00:00:00 +0000
+++ plugins/place/src/smart/include/smart.h	2012-01-30 18:23:23 +0000
@@ -0,0 +1,73 @@
+/*
+ * 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_SMART_H
+#define _COMPIZ_PLACE_SMART_H
+
+#include <vector>
+#include <core/rect.h>
+#include <core/windowgeometry.h>
+#include <core/windowextents.h>
+#include <core/size.h>
+#include <core/point.h>
+
+namespace compiz
+{
+    namespace place
+    {
+
+	extern const unsigned int WindowAbove;
+	extern const unsigned int WindowBelow;
+
+	class Placeable
+	{
+	    public:
+
+		typedef std::vector <Placeable *> Vector;
+
+		const compiz::window::Geometry & geometry () const { return getGeometry (); }
+		const compiz::window::extents::Extents & extents () const { return getExtents (); }
+		const CompRect & workArea () const { return getWorkarea (); }
+
+		unsigned int state () const { return getState (); }
+
+		virtual ~Placeable () = 0;
+
+	    protected:
+
+		virtual const compiz::window::Geometry & getGeometry () const = 0;
+		virtual const compiz::window::extents::Extents & getExtents () const = 0;
+		virtual const CompRect & getWorkarea () const = 0;
+
+		virtual unsigned int getState () const = 0;
+
+		Placeable ();
+	};
+
+	void smart (Placeable                      *placeable,
+		    CompPoint			   &pos,
+		    const compiz::place::Placeable::Vector &placeables);
+
+    }
+}
+
+#endif

=== added directory 'plugins/place/src/smart/src'
=== added file 'plugins/place/src/smart/src/smart.cpp'
--- plugins/place/src/smart/src/smart.cpp	1970-01-01 00:00:00 +0000
+++ plugins/place/src/smart/src/smart.cpp	2012-01-30 18:23:23 +0000
@@ -0,0 +1,199 @@
+#include "smart.h"
+#include <boost/foreach.hpp>
+
+#ifndef foreach
+#define foreach BOOST_FOREACH
+#endif
+
+/* overlap types */
+#define NONE    0
+#define H_WRONG -1
+#define W_WRONG -2
+
+namespace compiz
+{
+    namespace place
+    {
+	const unsigned int WindowAbove = 1 << 0;
+	const unsigned int WindowBelow = 1 << 1;
+
+	Placeable::Placeable ()
+	{
+	}
+
+	Placeable::~Placeable ()
+	{
+	}
+
+	void smart (Placeable                      *placeable,
+		    CompPoint			   &pos,
+		    const compiz::place::Placeable::Vector &placeables)
+	{
+	    /*
+	     * SmartPlacement by Cristian Tibirna ([e-mail])
+	     * adapted for kwm (16-19jan98) and for kwin (16Nov1999) using (with
+	     * permission) ideas from fvwm, authored by
+	     * Anthony Martin ([e-mail]).
+	     * Xinerama supported added by Balaji Ramani ([e-mail])
+	     * with ideas from xfce.
+	     * adapted for Compiz by Bellegarde Cedric (gnumdk(at)gmail.com)
+	     */
+	    int overlap = 0, minOverlap = 0;
+
+	    /* temp holder */
+	    int basket = 0;
+	    /* CT lame flag. Don't like it. What else would do? */
+	    bool firstPass = true;
+
+	    /* get the maximum allowed windows space */
+	    int xTmp = placeable->workArea ().x ();
+	    int yTmp = placeable->workArea ().y ();
+
+	    /* client gabarit */
+	    int cw = placeable->geometry ().width () - 1;
+	    int ch = placeable->geometry ().height () - 1;
+
+	    int xOptimal = xTmp;
+	    int yOptimal = yTmp;
+
+	    /* loop over possible positions */
+	    do
+	    {
+		/* test if enough room in x and y directions */
+		if (yTmp + ch > placeable->workArea ().bottom () && ch < placeable->workArea ().height ())
+		    overlap = H_WRONG; /* this throws the algorithm to an exit */
+		else if (xTmp + cw > placeable->workArea ().right ())
+		    overlap = W_WRONG;
+		else
+		{
+		    overlap = NONE; /* initialize */
+
+		    int cxl = xTmp;
+		    int cxr = xTmp + cw;
+		    int cyt = yTmp;
+		    int cyb = yTmp + ch;
+
+		    foreach (Placeable *p, placeables)
+		    {
+			const compiz::window::Geometry &otherGeometry = p->geometry ();
+			const compiz::window::extents::Extents &otherExtents = p->extents ();
+
+			int xl = otherGeometry.x () - otherExtents.left;
+			int yt = otherGeometry.y () - otherExtents.top;
+			int xr = otherGeometry.x2 () + otherExtents.right + otherGeometry.border () * 2;
+			int yb = otherGeometry.y2 () + otherExtents.bottom + otherGeometry.border () * 2;
+
+			/* if windows overlap, calc the overall overlapping */
+			if (cxl < xr && cxr > xl && cyt < yb && cyb > yt)
+			{
+			    xl = MAX (cxl, xl);
+			    xr = MIN (cxr, xr);
+			    yt = MAX (cyt, yt);
+			    yb = MIN (cyb, yb);
+
+			    if (p->state () & compiz::place::WindowAbove)
+				overlap += 16 * (xr - xl) * (yb - yt);
+			    else if (p->state () & compiz::place::WindowBelow)
+				overlap += 0;
+			    else
+				overlap += (xr - xl) * (yb - yt);
+			}
+		    }
+		}
+
+		/* CT first time we get no overlap we stop */
+		if (overlap == NONE)
+		{
+		    xOptimal = xTmp;
+		    yOptimal = yTmp;
+		    break;
+		}
+
+		if (firstPass)
+		{
+		    firstPass  = false;
+		    minOverlap = overlap;
+		}
+		/* CT save the best position and the minimum overlap up to now */
+		else if (overlap >= NONE && overlap < minOverlap)
+		{
+		    minOverlap = overlap;
+		    xOptimal = xTmp;
+		    yOptimal = yTmp;
+		}
+
+		/* really need to loop? test if there's any overlap */
+		if (overlap > NONE)
+		{
+		    int possible = placeable->workArea ().right ();
+
+		    if (possible - cw > xTmp)
+			possible -= cw;
+
+		    /* compare to the position of each client on the same desk */
+		    foreach (Placeable *p, placeables)
+		    {
+			const compiz::window::Geometry &otherGeometry = p->geometry ();
+			const compiz::window::extents::Extents &otherExtents = p->extents ();
+
+			int xl = otherGeometry.x () - otherExtents.left;
+			int yt = otherGeometry.y () - otherExtents.top;
+			int xr = otherGeometry.x2 () + otherExtents.right + otherGeometry.border () * 2;
+			int yb = otherGeometry.y2 () + otherExtents.bottom + otherGeometry.border () * 2;
+
+			/* if not enough room above or under the current
+			 * client determine the first non-overlapped x position
+			 */
+			if (yTmp < yb && yt < ch + yTmp)
+			{
+			    if (xr > xTmp && possible > xr)
+				possible = xr;
+
+			    basket = xl - cw;
+			    if (basket > xTmp && possible > basket)
+				possible = basket;
+			}
+		    }
+		    xTmp = possible;
+		}
+		/* else ==> not enough x dimension (overlap was wrong on horizontal) */
+		else if (overlap == W_WRONG)
+		{
+		    xTmp     = placeable->workArea ().x ();
+		    int possible = placeable->workArea ().bottom ();
+
+		    if (possible - ch > yTmp)
+			possible -= ch;
+
+		    /* test the position of each window on the desk */
+		    foreach (Placeable *p, placeables)
+		    {
+			const compiz::window::Geometry &otherGeometry = p->geometry ();
+			const compiz::window::extents::Extents &otherExtents = p->extents ();
+
+			int yt = otherGeometry.y () - otherExtents.top;
+			int yb = otherGeometry.y2 () + otherExtents.bottom + otherGeometry.border () * 2;
+
+			/* if not enough room to the left or right of the current
+			 * client determine the first non-overlapped y position
+			 */
+			if (yb > yTmp && possible > yb)
+			    possible = yb;
+
+			basket = yt - ch;
+			if (basket > yTmp && possible > basket)
+			    possible = basket;
+		    }
+		    yTmp = possible;
+		}
+	    }
+	    while (overlap != NONE && overlap != H_WRONG && yTmp < placeable->workArea ().bottom ());
+
+	    if (ch >= placeable->workArea ().height ())
+		yOptimal = placeable->workArea ().y ();
+
+	    pos.setX (xOptimal + placeable->extents ().left);
+	    pos.setY (yOptimal + placeable->extents ().top);
+	}
+    }
+}

=== added directory 'plugins/place/src/smart/tests'
=== added file 'plugins/place/src/smart/tests/CMakeLists.txt'
--- plugins/place/src/smart/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/place/src/smart/tests/CMakeLists.txt	2012-01-30 18:23:23 +0000
@@ -0,0 +1,14 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+add_executable (compiz_test_place_smart_on_screen
+                ${CMAKE_CURRENT_SOURCE_DIR}/offscreen/src/test-place-smart-on-screen.cpp)
+
+target_link_libraries (compiz_test_place_smart_on_screen
+		       compiz_place_smart
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread. 
+                       )
+
+add_test (compiz_place_smart_on_screen compiz_test_place_smart_on_screen)

=== added directory 'plugins/place/src/smart/tests/offscreen'
=== added directory 'plugins/place/src/smart/tests/offscreen/src'
=== added file 'plugins/place/src/smart/tests/offscreen/src/test-place-smart-on-screen.cpp'
--- plugins/place/src/smart/tests/offscreen/src/test-place-smart-on-screen.cpp	1970-01-01 00:00:00 +0000
+++ plugins/place/src/smart/tests/offscreen/src/test-place-smart-on-screen.cpp	2012-01-30 18:23:23 +0000
@@ -0,0 +1,156 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "smart.h"
+#include <iostream>
+#include <stdlib.h>
+#include <cstring>
+
+#include <boost/foreach.hpp>
+
+#ifndef foreach
+#define foreach BOOST_FOREACH
+#endif
+
+class CompPlaceSmartOffscreenTest :
+    public ::testing::Test
+{
+};
+
+class MockPlaceableObject :
+    public compiz::place::Placeable
+{
+    public:
+
+	MockPlaceableObject (const compiz::window::Geometry &geometry,
+			     const compiz::window::extents::Extents &extents,
+			     const std::vector <CompRect *> &availableWorkareas);
+
+	const compiz::window::Geometry & getGeometry () const { return mGeometry; }
+	const CompRect                 & getWorkarea () const { return *mWorkarea; }
+	const compiz::window::extents::Extents & getExtents () const { return mExtents; }
+	unsigned int getState () const { return 0; }
+
+    private:
+
+	compiz::window::Geometry mGeometry;
+	CompRect                 *mWorkarea;
+	compiz::window::extents::Extents mExtents;
+};
+
+MockPlaceableObject::MockPlaceableObject (const compiz::window::Geometry &geometry,
+					  const compiz::window::extents::Extents &extents,
+					  const std::vector <CompRect *> &availableWorkareas) :
+    compiz::place::Placeable::Placeable (),
+    mGeometry (geometry),
+    mExtents (extents)
+{
+    unsigned int areaMax = 0;
+    CompRect     *running = availableWorkareas.front ();
+
+    /* Pick the workarea that we best intersect */
+    foreach (CompRect *rect, availableWorkareas)
+    {
+	unsigned int area = abs ((*rect & static_cast <CompRect> (geometry)).area ());
+
+	if (area > areaMax)
+	{
+	    running = rect;
+	    areaMax = area;
+	}
+    }
+
+    mWorkarea = running;
+}
+
+TEST_F (CompPlaceSmartOffscreenTest, TestOffscreenOne)
+{
+    CompRect wa1 (0, 24, 1680, 1026);
+    CompRect wa2 (1680, 24, 1024, 744);
+    compiz::place::Placeable::Vector v;
+
+    std::vector <CompRect *> workAreas;
+    workAreas.push_back (&wa1);
+    workAreas.push_back (&wa2);
+
+    /* Intersects 1 */
+    compiz::window::Geometry g (0, 0, 640, 480, 0);
+    compiz::window::extents::Extents e;
+
+    e.left = 10;
+    e.right = 10;
+    e.top = 10;
+    e.bottom = 10;
+
+    MockPlaceableObject p (g, e, workAreas);
+
+    CompPoint pos (g.x (), g.y ());
+
+    compiz::place::smart (&p, pos, v);
+
+    EXPECT_EQ (pos, CompPoint (10, 34));
+
+    /* Intersects 2 */
+
+    g = compiz::window::Geometry (1681, 0, 640, 480, 0);
+
+    p = MockPlaceableObject (g, e, workAreas);
+
+    compiz::place::smart (&p, pos, v);
+
+    EXPECT_EQ (pos, CompPoint (1690, 34));
+
+    /* Intersects 2 partially */
+
+    g = compiz::window::Geometry (1681, 500, 640, 480, 0);
+
+    p = MockPlaceableObject (g, e, workAreas);
+
+    compiz::place::smart (&p, pos, v);
+
+    EXPECT_EQ (pos, CompPoint (1690, 34));
+
+    /* Intersects 1 + 2 partially (1 more) */
+
+    g = compiz::window::Geometry (1300, 500, 640, 480, 0);
+
+    p = MockPlaceableObject (g, e, workAreas);
+
+    compiz::place::smart (&p, pos, v);
+
+    EXPECT_EQ (pos, CompPoint (10, 34));
+
+    /* Intersects 1 + 2 partially (2 more) */
+
+    g = compiz::window::Geometry (1600, 500, 640, 480, 0);
+
+    p = MockPlaceableObject (g, e, workAreas);
+
+    compiz::place::smart (&p, pos, v);
+
+    EXPECT_EQ (pos, CompPoint (1690, 34));
+}

=== added file 'plugins/place/src/smart/tests/offscreen/src/test-place-smart-onscren.cpp'
--- plugins/place/src/smart/tests/offscreen/src/test-place-smart-onscren.cpp	1970-01-01 00:00:00 +0000
+++ plugins/place/src/smart/tests/offscreen/src/test-place-smart-onscren.cpp	2012-01-30 18:23:23 +0000
@@ -0,0 +1,107 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "smart.h"
+#include <iostream>
+#include <stdlib.h>
+#include <cstring>
+
+class CompPlaceSmartOffscreenTest :
+    public ::testing::Test
+{
+};
+
+class MockPlaceableObject :
+    public compiz::place::Placeable
+{
+    public:
+
+	MockPlaceableObject (const compiz::window::Geometry &geometry,
+			     const compiz::window::extents::Extents &extents,
+			     const std::vector <CompRect *> &availableWorkareas);
+	
+	const compiz::window::Geometry & getGeometry () const { return mGeometry; }
+	const CompRect                 & getWorkarea () const { return *mWorkarea; }
+	const compiz::window::extents::Extents & getExtents () const { return mExtents; }
+
+    private:
+
+	compiz::window::Geometry mGeometry;
+	CompRect                 *mWorkarea;
+	compiz::window::extents::Extents mExtents;
+}
+
+MockPlaceableObject::MockPlaceableObject (const compiz::window::Geometry &geometry,
+					  const compiz::window::extents::Extents &extents,
+					  const std::vector <CompRect *> &availableWorkareas) :
+    compiz::place::Placeable::Placeable (),
+    mGeometry (geometry),
+    mExtents (extents)
+{
+    unsigned int areaMax = 0;
+    CompRect     *running = availableWorkareas.front ();
+
+    /* Pick the workarea that we best intersect */
+    foreach (CompRect *rect, availableWorkareas)
+    {
+	unsigned int area = abs ((*rect & static_cast <CompRect &> (geometry)).area ());
+
+	if (area > areaMax)
+	{
+	    running = rect;
+	    areaMax = area;
+	}
+    }
+
+    mWorkarea = running;
+}
+
+TEST_F (CompPlaceSmartOffscreenTest, TestOffscreenOne)
+{
+    CompRect wa1 (0, 24, 1680, 1026);
+    CompRect wa2 (1680, 24, 1024, 744);
+    compiz::place::Placeable::Vector v;
+
+    std::vector <CompRect *> workAreas;
+    workAreas.push_back (&wa1);
+    workAreas.push_back (&wa2);
+
+    /* Intersects 1 */
+    compiz::window::Geometry g (0, 0, 640, 480);
+    compiz::window::extents::Extents e (10, 10, 10, 10);
+
+    MockPlaceableObject p (g, e, workAreas);
+
+    CompPoint pos (g.x (), g.y ());
+
+    compiz::place::smart (p, pos, v);
+
+    std::cout << pos.x () << pos.y () << std::endl;
+
+    EXPECT_EQ (pos, CompPoint (0, 0));
+}
+