Merge lp:~smspillaz/compiz-grid-plugin/oneiric.maybe_fix_corruption_placement into lp:compiz-grid-plugin

[Sam Spilsbury]

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2009-12-17 12:22:47 +0000
+++ CMakeLists.txt	2011-10-03 00:29:23 +0000
@@ -2,4 +2,6 @@
 
 include (CompizPlugin)
 
+set (CMAKE_CXX_FLAGS -std=c++0x)
+
 compiz_plugin(grid PLUGINDEPS composite opengl)
 
=== modified file 'grid.xml.in'
--- grid.xml.in	2010-09-28 22:30:57 +0000
+++ grid.xml.in	2011-10-03 00:29:23 +0000
@@ -84,7 +84,7 @@
 			<option name="top_left_corner_action" type="int">
 			    <_short>Upper Left Corner</_short>
 			    <_long>Action to be performed when window is dropped on the top left corner</_long>
-			    <default>7</default>
+			    <default>4</default>
 			    <min>0</min>
 			    <max>10</max>
 			    <desc>
@@ -186,7 +186,7 @@
 			<option name="top_right_corner_action" type="int">
 			    <_short>Upper Right Corner</_short>
 			    <_long>Action to be performed when window is dropped on the top right corner</_long>
-			    <default>9</default>
+			    <default>6</default>
 			    <min>0</min>
 			    <max>10</max>
 			    <desc>
@@ -339,7 +339,7 @@
 			<option name="bottom_left_corner_action" type="int">
 			    <_short>Bottom Left Corner</_short>
 			    <_long>Action to be performed when window is dropped on the bottom left corner</_long>
-			    <default>1</default>
+			    <default>4</default>
 			    <min>0</min>
 			    <max>10</max>
 			    <desc>
@@ -390,7 +390,7 @@
 			<option name="bottom_edge_action" type="int">
 			    <_short>Bottom Edge</_short>
 			    <_long>Action to be performed when window is dropped on the bottom edge</_long>
-			    <default>2</default>
+			    <default>0</default>
 			    <min>0</min>
 			    <max>10</max>
 			    <desc>
@@ -441,7 +441,7 @@
 			<option name="bottom_right_corner_action" type="int">
 			    <_short>Bottom Right Corner</_short>
 			    <_long>Action to be performed when window is dropped on the bottom right corner</_long>
-			    <default>3</default>
+			    <default>6</default>
 			    <min>0</min>
 			    <max>10</max>
 			    <desc>
@@ -505,21 +505,21 @@
 			<option name="left_edge_threshold" type="int">
 				<_short>Left Edge</_short>
 				<_long>Maximum number of pixels from the left edge a window can be dropped</_long>
-				<default>5</default>
+				<default>15</default>
 				<min>0</min>
 				<max>500</max>
 			</option>
 			<option name="right_edge_threshold" type="int">
 				<_short>Right Edge</_short>
 				<_long>Maximum number of pixels from the right edge a window can be dropped</_long>
-				<default>5</default>
+				<default>15</default>
 				<min>0</min>
 				<max>500</max>
 			</option>
 			<option name="top_edge_threshold" type="int">
 				<_short>Top Edge</_short>
 				<_long>Maximum number of pixels from the top edge a window can be dropped</_long>
-				<default>5</default>
+				<default>20</default>
 				<min>0</min>
 				<max>500</max>
 			</option>
@@ -543,9 +543,9 @@
 			<_short>Outline Color</_short>
 			<_long>Color of the resize indicator outline</_long>
 			<default>
-			    <red>0x2f2f</red>
-			    <green>0x2f2f</green>
-			    <blue>0x4f4f</blue>
+			    <red>0xfbfb</red>
+			    <green>0x8b8b</green>
+			    <blue>0x0</blue>
 			    <alpha>0x9f9f</alpha>
 			</default>
 		</option>
@@ -553,9 +553,9 @@
 			<_short>Fill Color</_short>
 			<_long>Fill color of the resize indicator</_long>
 			<default>
-			    <red>0x2f2f</red>
-			    <green>0x2f2f</green>
-			    <blue>0x4f4f</blue>
+			    <red>0xfbfb</red>
+			    <green>0x8b8b</green>
+			    <blue>0x0</blue>
 			    <alpha>0x4f4f</alpha>
 			</default>
 		</option>
 
=== modified file 'src/grid.cpp'
--- src/grid.cpp	2011-09-29 15:54:11 +0000
+++ src/grid.cpp	2011-10-03 00:29:23 +0000
@@ -24,24 +24,26 @@
 
 #include "grid.h"
 
-static const GridProps gridProps[] =
+using namespace GridWindowType;
+
+static std::map <unsigned int, GridProps> gridProps;
+
+void
+GridScreen::handleCompizEvent(const char*    plugin,
+			      const char*    event,
+			      CompOption::Vector&  o)
 {
-    {0,1, 1,1},
-
-    {0,1, 2,2},
-    {0,1, 1,2},
-    {1,1, 2,2},
-
-    {0,0, 2,1},
-    {0,0, 1,1},
-    {1,0, 2,1},
-
-    {0,0, 2,2},
-    {0,0, 1,2},
-    {1,0, 2,2},
-
-    {0,0, 1,1},
-};
+    if (strcmp(event, "start_viewport_switch") == 0)
+    {
+	mSwitchingVp = true;
+    }
+    else if (strcmp(event, "end_viewport_switch") == 0)
+    {
+	mSwitchingVp = false;
+    }
+
+  screen->handleCompizEvent(plugin, event, o);
+}
 
 CompRect
 GridScreen::slotToRect (CompWindow      *w,
@@ -83,7 +85,7 @@
 void
 GridScreen::getPaintRectangle (CompRect &cRect)
 {
-    if (edgeToGridType () != GridUnknown && optionGetDrawIndicator ())
+    if (typeToMask (edgeToGridType ()) != GridUnknown && optionGetDrawIndicator ())
 	cRect = desiredSlot;
     else
 	cRect.setGeometry (0, 0, 0, 0);
@@ -118,8 +120,14 @@
 GridScreen::initiateCommon (CompAction         *action,
 			    CompAction::State  state,
 			    CompOption::Vector &option,
+<<<<<<< TREE
 			    GridType           where,
 			    bool               resize)
+=======
+			    unsigned int                where,
+			    bool               resize,
+			    bool	       key)
+>>>>>>> MERGE-SOURCE
 {
     Window     xid;
     CompWindow *cw = 0;
@@ -127,16 +135,27 @@
     xid = CompOption::getIntOptionNamed (option, "window");
     cw  = screen->findWindow (xid);
 
-    if (where == GridUnknown || screen->otherGrabExist ("move", NULL))
-	return false;
-
     if (cw)
     {
 	XWindowChanges xwc;
+	bool maximizeH = where & (GridBottom | GridTop | GridMaximize);
+	bool maximizeV = where & (GridLeft | GridRight | GridMaximize);
+
+	if (!(cw->actions () & CompWindowActionResizeMask))
+	    return false;
+
+	if (maximizeH && !(cw->actions () & CompWindowActionMaximizeHorzMask))
+	    return false;
+
+	if (maximizeV && !(cw->actions () & CompWindowActionMaximizeVertMask))
+	    return false;
+
+	if (where & GridUnknown)
+	    return false;
 
 	GRID_WINDOW (cw);
 
-	if (gw->lastTarget != where)
+	if (gw->lastTarget & ~(where))
 	    gw->resizeCount = 0;
 
 	props = gridProps[where];
@@ -164,7 +183,7 @@
 	    cw->maximize (0);
 	}
 
-	if (where == GridMaximize && resize)
+	if ((where & GridMaximize) && resize)
 	{
 	    /* move the window to the correct output */
 	    if (cw == mGrabWindow)
@@ -198,7 +217,13 @@
 	desiredSlot.setWidth (workarea.width () / props.numCellsX);
 
 	/* Adjust for constraints and decorations */
-	desiredRect = constrainSize (cw, desiredSlot);
+	if (where & ~(GridMaximize | GridLeft | GridRight))
+	{
+	    desiredRect = constrainSize (cw, desiredSlot);
+	}
+	else
+	    desiredRect = slotToRect (cw, desiredSlot);
+
 	/* Get current rect not including decorations */
 	currentRect.setGeometry (cw->serverX (), cw->serverY (),
 				 cw->serverWidth (),
@@ -206,7 +231,7 @@
 
 	if (desiredRect.y () == currentRect.y () &&
 	    desiredRect.height () == currentRect.height () &&
-	    where != GridMaximize && gw->lastTarget == where)
+	    where & ~(GridMaximize | GridLeft | GridRight) && gw->lastTarget & where)
 	{
 	    int slotWidth25  = workarea.width () / 4;
 	    int slotWidth33  = (workarea.width () / 3) + cw->border ().left;
@@ -319,12 +344,71 @@
 	/* TODO: animate move+resize */
 	if (resize)
 	{
+<<<<<<< TREE
 	    cw->configureXWindow (CWX | CWY | CWWidth | CWHeight, &xwc);
 	    gw->isGridResized = true;
 	    gw->isGridMaximized = false;
 		for (unsigned int i = 0; i < animations.size (); i++)
 			animations.at (i).fadingOut = true;
 	    gw->lastTarget = where;
+=======
+	    unsigned int valueMask = CWX | CWY | CWWidth | CWHeight;
+	    gw->lastTarget = where;
+	    gw->currentSize = CompRect (wc.x, wc.y, wc.width, wc.height);
+	    CompWindowExtents lastBorder = gw->window->border ();
+
+	    gw->sizeHintsFlags = 0;
+
+	    /* Special case for left and right, actually vertically maximize
+	     * the window */
+	    if (where & GridLeft || where & GridRight)
+	    {
+		/* First restore the window to its original size */
+		XWindowChanges rwc;
+
+		rwc.x = gw->originalSize.x ();
+		rwc.y = gw->originalSize.y ();
+		rwc.width = gw->originalSize.width ();
+		rwc.height = gw->originalSize.height ();
+
+		cw->configureXWindow (CWX | CWY | CWWidth | CWHeight, &rwc);
+
+		gw->isGridMaximized = true;
+		gw->isGridResized = false;
+
+		/* Maximize the window */
+		cw->maximize (CompWindowStateMaximizedVertMask);
+
+		/* Be evil */
+		if (cw->sizeHints ().flags & PResizeInc)
+		{
+		    gw->sizeHintsFlags |= PResizeInc;
+		    gw->window->sizeHints ().flags &= ~(PResizeInc);
+		}
+	    }
+	    else
+	    {
+	        gw->isGridResized = true;
+	        gw->isGridMaximized = false;
+	    }
+
+	    int dw = (lastBorder.left + lastBorder.right) - 
+		      (gw->window->border ().left +
+		       gw->window->border ().right);
+			
+	    int dh = (lastBorder.top + lastBorder.bottom) - 
+			(gw->window->border ().top +
+			 gw->window->border ().bottom);
+
+	    xwc.width += dw;
+	    xwc.height += dh;
+
+	    /* Make window the size that we want */
+	    cw->configureXWindow (valueMask, &xwc);
+
+	    for (unsigned int i = 0; i < animations.size (); i++)
+		animations.at (i).fadingOut = true;
+>>>>>>> MERGE-SOURCE
 	}
 
 	/* This centers a window if it could not be resized to the desired
@@ -452,39 +536,72 @@
     return status;
 }
 
-GridType
+unsigned int
+GridScreen::typeToMask (int t)
+{
+    typedef struct {
+	unsigned int mask;
+	int type;
+    } GridTypeMask;
+
+    std::vector <GridTypeMask> type =
+    {
+	{ GridWindowType::GridUnknown, 0 },
+	{ GridWindowType::GridBottomLeft, 1 },
+	{ GridWindowType::GridBottom, 2 },
+	{ GridWindowType::GridBottomRight, 3 },
+	{ GridWindowType::GridLeft, 4 },
+	{ GridWindowType::GridCenter, 5 },
+	{ GridWindowType::GridRight, 6 },
+	{ GridWindowType::GridTopLeft, 7 },
+	{ GridWindowType::GridTop, 8 },
+	{ GridWindowType::GridTopRight, 9 },
+	{ GridWindowType::GridMaximize, 10 }
+    };
+
+    for (unsigned int i = 0; i < type.size (); i++)
+    {
+	GridTypeMask &tm = type[i];
+	if (tm.type == t)
+	    return tm.mask;
+    }
+
+    return GridWindowType::GridUnknown;
+}
+
+int
 GridScreen::edgeToGridType ()
 {
-    GridType ret;
+    int ret;
 
     switch (edge) {
     case Left:
-	ret = (GridType) optionGetLeftEdgeAction ();
+	ret = (int) optionGetLeftEdgeAction ();
 	break;
     case Right:
-	ret = (GridType) optionGetRightEdgeAction ();
+	ret = (int) optionGetRightEdgeAction ();
 	break;
     case Top:
-	ret = (GridType) optionGetTopEdgeAction ();
+	ret = (int) optionGetTopEdgeAction ();
 	break;
     case Bottom:
-	ret = (GridType) optionGetBottomEdgeAction ();
+	ret = (int) optionGetBottomEdgeAction ();
 	break;
     case TopLeft:
-	ret = (GridType) optionGetTopLeftCornerAction ();
+	ret = (int) optionGetTopLeftCornerAction ();
 	break;
     case TopRight:
-	ret = (GridType) optionGetTopRightCornerAction ();
+	ret = (int) optionGetTopRightCornerAction ();
 	break;
     case BottomLeft:
-	ret = (GridType) optionGetBottomLeftCornerAction ();
+	ret = (int) optionGetBottomLeftCornerAction ();
 	break;
     case BottomRight:
-	ret = (GridType) optionGetBottomRightCornerAction ();
+	ret = (int) optionGetBottomRightCornerAction ();
 	break;
     case NoEdge:
     default:
-	ret = GridUnknown;
+	ret = -1;
 	break;
     }
 
@@ -548,7 +665,11 @@
 	if (cScreen)
 	    cScreen->damageRegion (desiredSlot);
 
+<<<<<<< TREE
 	initiateCommon (0, 0, o, edgeToGridType (), false);
+=======
+	initiateCommon (0, 0, o, typeToMask (edgeToGridType ()), false, false);
+>>>>>>> MERGE-SOURCE
 
 	if (cScreen)
 	    cScreen->damageRegion (desiredSlot);
@@ -566,7 +687,11 @@
 		if (cScreen)
 			cScreen->damageRegion (desiredSlot);
 
+<<<<<<< TREE
 		initiateCommon (0, 0, o, edgeToGridType (), false);
+=======
+		check = initiateCommon (NULL, 0, o, typeToMask (edgeToGridType ()), false, false);
+>>>>>>> MERGE-SOURCE
 
 		if (cScreen)
 			cScreen->damageRegion (desiredSlot);
@@ -614,12 +739,27 @@
 }
 
 void
+GridWindow::validateResizeRequest (unsigned int &xwcm,
+				   XWindowChanges *xwc,
+				   unsigned int source)
+{
+    window->validateResizeRequest (xwcm, xwc, source);
+
+    /* Don't allow non-pagers to change
+     * the size of the window, the user
+     * specified this size, thank-you */
+    if (isGridMaximized)
+	if (source != ClientTypePager)
+	    xwcm = 0;
+}
+
+void
 GridWindow::grabNotify (int          x,
 			int          y,
 			unsigned int state,
 			unsigned int mask)
 {
-    if (screen->grabExist ("move"))
+    if (mask & (CompWindowGrabMoveMask | CompWindowGrabButtonMask))
     {
 	gScreen->o.push_back (CompOption ("window", CompOption::TypeInt));
 	gScreen->o[0].value ().set ((int) window->id ());
@@ -627,14 +767,15 @@
 	screen->handleEventSetEnabled (gScreen, true);
 	gScreen->mGrabWindow = window;
 	pointerBufDx = pointerBufDy = 0;
+	grabMask = mask;
 
-	if (!isGridResized && gScreen->optionGetSnapbackWindows ())
+	if (!isGridResized && !isGridMaximized && gScreen->optionGetSnapbackWindows ())
 	    /* Store size not including borders when grabbing with cursor */
 	    originalSize = gScreen->slotToRect(window,
 						    window->serverBorderRect ());
     }
 
-    if (screen->grabExist ("resize"))
+    if (mask & CompWindowGrabResizeMask)
     {
 	isGridResized = false;
 	resizeCount = 0;
@@ -649,9 +790,15 @@
     if (window == gScreen->mGrabWindow)
     {
 	gScreen->initiateCommon
+<<<<<<< TREE
 			(0, 0, gScreen->o, gScreen->edgeToGridType (), true);
+=======
+			(NULL, 0, gScreen->o, gScreen->typeToMask (gScreen->edgeToGridType ()), true,
+			 gScreen->edge != gScreen->lastResizeEdge);
+>>>>>>> MERGE-SOURCE
 
 	screen->handleEventSetEnabled (gScreen, false);
+	grabMask = 0;
 	gScreen->mGrabWindow = NULL;
 	gScreen->cScreen->damageRegion (gScreen->desiredSlot);
     }
@@ -666,6 +813,7 @@
 {
     window->moveNotify (dx, dy, immediate);
 
+<<<<<<< TREE
     if (isGridResized)
     {
 	pointerBufDx += dx;
@@ -678,8 +826,48 @@
 	window->move (-dx, -dy);
 	window->moveNotifySetEnabled (this, true);
     }
-}
-
+=======
+    if (isGridResized && !isGridMaximized && !GridScreen::get (screen)->mSwitchingVp)
+    {
+	if (window->grabbed () && (grabMask & CompWindowGrabMoveMask))
+	{
+	    pointerBufDx += dx;
+	    pointerBufDy += dy;
+	}
+
+	/* Do not allow the window to be moved while it
+	 * is resized */
+	dx = currentSize.x () - window->geometry ().x ();
+	dy = currentSize.y () - window->geometry ().y ();
+
+	window->move (dx, dy);
+    }
+>>>>>>> MERGE-SOURCE
+}
+
+<<<<<<< TREE
+=======
+void
+GridWindow::stateChangeNotify (unsigned int lastState)
+{
+    if (lastState & MAXIMIZE_STATE &&
+	!(window->state () & MAXIMIZE_STATE))
+	lastTarget = GridUnknown;
+    else if (!(lastState & MAXIMIZE_STATE) &&
+	     window->state () & MAXIMIZE_STATE)
+    {
+	lastTarget = GridMaximize;
+	if (window->grabbed ())
+	{
+	    originalSize = gScreen->slotToRect (window,
+					        window->serverBorderRect ());
+	}
+    }
+
+    window->stateChangeNotify (lastState);
+}
+
+>>>>>>> MERGE-SOURCE
 bool
 GridScreen::restoreWindow (CompAction         *action,
 			   CompAction::State  state,
@@ -697,7 +885,10 @@
 	return false;
 
     if (gw->isGridMaximized & !(cw->state () & MAXIMIZE_STATE))
-	    gw->isGridMaximized = false;
+    {
+	gw->window->sizeHints ().flags |= gw->sizeHintsFlags;
+	gw->isGridMaximized = false;
+    }
     else
     {
         if (cw == mGrabWindow)
@@ -713,6 +904,7 @@
 	xwc.width  = gw->originalSize.width ();
 	xwc.height = gw->originalSize.height ();
 	cw->maximize (0);
+	gw->currentSize = CompRect ();
 	cw->configureXWindow (CWX | CWY | CWWidth | CWHeight, &xwc);
 	gw->pointerBufDx = 0;
 	gw->pointerBufDy = 0;
@@ -818,16 +1010,29 @@
     glScreen (GLScreen::get (screen)),
     centerCheck (false),
     mGrabWindow (NULL),
-    animating (false)
+    animating (false),
+    mSwitchingVp (false)
 {
 
     ScreenInterface::setHandler (screen, false);
+    screen->handleCompizEventSetEnabled (this, true);
     CompositeScreenInterface::setHandler (cScreen, false);
     GLScreenInterface::setHandler (glScreen, false);
 
     edge = lastEdge = NoEdge;
     currentWorkarea = lastWorkarea = screen->getWorkareaForOutput
 			    (screen->outputDeviceForPoint (pointerX, pointerY));
+    gridProps[GridUnknown] = GridProps {0,1, 1,1};
+    gridProps[GridBottomLeft]  = GridProps {0,1, 2,2};
+    gridProps[GridBottom]  = GridProps {0,1, 1,2};
+    gridProps[GridBottomRight] = GridProps {1,1, 2,2};
+    gridProps[GridLeft]  = GridProps {0,0, 2,1};
+    gridProps[GridCenter]  = GridProps{0,0, 1,1};
+    gridProps[GridRight]  = GridProps {1,0, 2,1};
+    gridProps[GridTopLeft]  = GridProps{0,0, 2,2};
+    gridProps[GridTop]  = GridProps {0,0, 1,2};
+    gridProps[GridTopRight]  = GridProps {0,0, 1,2};
+    gridProps[GridMaximize]  = GridProps {0,0, 1,1};
 
 	animations.clear ();
 
@@ -835,6 +1040,7 @@
     optionSet##opt##Initiate (boost::bind (&GridScreen::initiateCommon, this,  \
 					   _1, _2, _3, where, resize))
 
+<<<<<<< TREE
     GRIDSET (PutCenterKey, GridCenter, true);
     GRIDSET (PutLeftKey, GridLeft, true);
     GRIDSET (PutRightKey, GridRight, true);
@@ -845,6 +1051,18 @@
     GRIDSET (PutBottomleftKey, GridBottomLeft, true);
     GRIDSET (PutBottomrightKey, GridBottomRight, true);
     GRIDSET (PutMaximizeKey, GridMaximize, true);
+=======
+    GRIDSET (PutCenterKey, GridWindowType::GridCenter, true, true);
+    GRIDSET (PutLeftKey, GridWindowType::GridLeft, true, true);
+    GRIDSET (PutRightKey, GridWindowType::GridRight, true, true);
+    GRIDSET (PutTopKey, GridWindowType::GridTop, true, true);
+    GRIDSET (PutBottomKey, GridWindowType::GridBottom, true, true);
+    GRIDSET (PutTopleftKey, GridWindowType::GridTopLeft, true, true);
+    GRIDSET (PutToprightKey, GridWindowType::GridTopRight, true, true);
+    GRIDSET (PutBottomleftKey, GridWindowType::GridBottomLeft, true, true);
+    GRIDSET (PutBottomrightKey, GridWindowType::GridBottomRight, true, true);
+    GRIDSET (PutMaximizeKey, GridWindowType::GridMaximize, true, true);
+>>>>>>> MERGE-SOURCE
 
 #undef GRIDSET
 
@@ -862,9 +1080,10 @@
     gScreen (GridScreen::get (screen)),
     isGridResized (false),
     isGridMaximized (false),
+    grabMask (0),
     pointerBufDx (0),
     pointerBufDy (0),
-    resizeCount (0),
+    resizeCount (0),	
     lastTarget (GridUnknown)
 {
     WindowInterface::setHandler (window);
 
=== modified file 'src/grid.h'
--- src/grid.h	2011-09-29 15:54:11 +0000
+++ src/grid.h	2011-10-03 00:29:23 +0000
@@ -32,20 +32,22 @@
 
 #define SNAPOFF_THRESHOLD 50
 
-typedef enum
+namespace GridWindowType
 {
-    GridUnknown = 0,
-    GridBottomLeft = 1,
-    GridBottom = 2,
-    GridBottomRight = 3,
-    GridLeft = 4,
-    GridCenter = 5,
-    GridRight = 6,
-    GridTopLeft = 7,
-    GridTop = 8,
-    GridTopRight = 9,
-    GridMaximize = 10
-} GridType;
+    static const unsigned int GridUnknown = (1 << 0);
+    static const unsigned int GridBottomLeft  = (1 << 1);
+    static const unsigned int GridBottom  = (1 << 2);
+    static const unsigned int GridBottomRight = (1 << 3);
+    static const unsigned int GridLeft  = (1 << 4);
+    static const unsigned int GridCenter  = (1 << 5);
+    static const unsigned int GridRight  = (1 << 6);
+    static const unsigned int GridTopLeft  = (1 << 7);
+    static const unsigned int GridTop  = (1 << 8);
+    static const unsigned int GridTopRight  = (1 << 9);
+    static const unsigned int GridMaximize  = (1 << 10);
+};
+
+typedef unsigned int GridType;
 
 typedef struct _GridProps
 {
@@ -106,12 +108,17 @@
 	bool centerCheck;
 	CompWindow *mGrabWindow;
 	bool animating;
+	bool mSwitchingVp;
 
 	void getPaintRectangle (CompRect&);
 	void setCurrentRect (Animation&);
 
 	bool initiateCommon (CompAction*, CompAction::State,
+<<<<<<< TREE
 			     CompOption::Vector&, GridType, bool);
+=======
+			     CompOption::Vector&, unsigned int, bool, bool);
+>>>>>>> MERGE-SOURCE
 
 	void glPaintRectangle (const GLScreenPaintAttrib&,
 			       const GLMatrix&, CompOutput *);
@@ -125,9 +132,11 @@
 
 	std::vector <Animation> animations;
 
-	GridType edgeToGridType ();
+	int edgeToGridType ();
+	unsigned int typeToMask (int);
 
 	void handleEvent (XEvent *event);
+	void handleCompizEvent (const char *plugin, const char *event, CompOption::Vector &options);
 
 	bool restoreWindow (CompAction*,
 			    CompAction::State,
@@ -157,17 +166,28 @@
 
 	bool isGridResized;
 	bool isGridMaximized;
+	unsigned int grabMask;
 	int pointerBufDx;
 	int pointerBufDy;
 	int resizeCount;
+	CompRect currentSize;
 	CompRect originalSize;
 	GridType lastTarget;
+	unsigned int sizeHintsFlags;
 
 	void grabNotify (int, int, unsigned int, unsigned int);
 
 	void ungrabNotify ();
 
 	void moveNotify (int, int, bool);
+<<<<<<< TREE
+=======
+
+	void stateChangeNotify (unsigned int);
+	void validateResizeRequest (unsigned int &valueMask,
+				    XWindowChanges *xwc,
+				    unsigned int source);
+>>>>>>> MERGE-SOURCE
 };
 
 #define GRID_WINDOW(w) \