Merge lp:~hikiko/compiz/compiz.move-additions into lp:compiz

[Eleni Maria Stea]

Move: add options for showing only the window shape (filled or not)

- the user can move the window (normal mode)
- a filled rectangle (rectangle mode) or
- a non-filled rectangle (outline mode)
also the user can enable and disable blend.

Non-blended outline mode can improve the performance in software rendering, thus using it in lowgfx profile.

New options in Move plugin:
- the user can move the window (normal mode)
- a filled rectangle (rectangle mode) or
- a non-filled rectangle (outline mode)
also the user can enable and disable blend.

Non-blended outline mode can improve the performance in software rendering.

[Marco Trevisan (Treviño) (3v1n0)]

Looks good, but please see comments for some improvements

[Marco Trevisan (Treviño) (3v1n0)]

Better thanks.

Just one line change. See diff comment.

[lp:~hikiko/compiz/compiz.move-additions]

4096. By Eleni Maria Stea on 2016-12-08

damage the rectangle when getMovingRectangle returns true

[Marco Trevisan (Treviño) (3v1n0)]

Thanks!

review: Approve

=== modified file 'debian/unity-lowgfx.ini'
--- debian/unity-lowgfx.ini	2016-09-08 09:37:01 +0000
+++ debian/unity-lowgfx.ini	2016-12-08 13:50:39 +0000
@@ -46,3 +46,7 @@
 
 [showdesktop]
 s0_skip_animation = true
+
+[move]
+s0_mode = 1
+s0_blend = false

=== modified file 'plugins/move/move.xml.in'
--- plugins/move/move.xml.in	2013-04-14 11:46:28 +0000
+++ plugins/move/move.xml.in	2016-12-08 13:50:39 +0000
@@ -70,6 +70,54 @@
 		<_long>Do not update the server-side position of windows until finished moving.</_long>
 		<default>false</default>
 	    </option>
+
+	    <group>
+	    <_short>Appearance</_short>
+		<option name="mode" type="int">
+		    <_short>Default Moving Window Mode</_short>
+		    <_long>Default mode used for window moving.</_long>
+		    <default>0</default>
+		    <min>0</min>
+		    <max>2</max>
+		    <desc>
+			<value>0</value>
+			<_name>Normal</_name>
+		    </desc>
+		    <desc>
+			<value>1</value>
+			<_name>Outline</_name>
+		    </desc>
+		    <desc>
+			<value>2</value>
+			<_name>Rectangle</_name>
+		    </desc>
+		</option>
+		<option name="border_color" type="color">
+		    <_short>Border Color</_short>
+		    <_long>Border color used for outline and rectangle moving modes</_long>
+		    <default>
+			<red>0xfbfb</red>
+			<green>0x8b8b</green>
+			<blue>0x0</blue>
+			<alpha>0x9f9f</alpha>
+		    </default>
+		</option>
+		<option name="fill_color" type="color">
+		    <_short>Fill Color</_short>
+		    <_long>Fill color used for rectangle moving mode</_long>
+		    <default>
+			<red>0xfbfb</red>
+			<green>0x8b8b</green>
+			<blue>0x0</blue>
+			<alpha>0x1919</alpha>
+		    </default>
+		</option>
+		<option name="blend" type="bool">
+		    <_short>Enable Transparency</_short>
+		    <_long>Enable or disable blending.</_long>
+		    <default>true</default>
+		</option>
+	    </group>
 	</options>
     </plugin>
 </compiz>

=== modified file 'plugins/move/src/move.cpp'
--- plugins/move/src/move.cpp	2015-10-20 15:11:54 +0000
+++ plugins/move/src/move.cpp	2016-12-08 13:50:39 +0000
@@ -34,6 +34,9 @@
 
 COMPIZ_PLUGIN_20090315 (move, MovePluginVTable)
 
+static float pos_x, pos_y;
+static bool paint_rectangle;
+
 static bool
 moveInitiate (CompAction         *action,
 	      CompAction::State  state,
@@ -43,6 +46,18 @@
 
     MOVE_SCREEN (screen);
 
+    if (ms->optionGetMode () != MoveOptions::ModeNormal)
+    {
+	ms->gScreen->glPaintOutputSetEnabled (ms, true);
+	paint_rectangle = true;
+	pos_x = pos_y = 0;
+    }
+    else
+    {
+	ms->gScreen->glPaintOutputSetEnabled (ms, false);
+	paint_rectangle = false;
+    }
+
     Window xid = CompOption::getIntOptionNamed (options, "window");
 
     w = screen->findWindow (xid);
@@ -173,13 +188,33 @@
 {
     MOVE_SCREEN (screen);
 
+    if (ms->optionGetMode () != MoveOptions::ModeNormal)
+    {
+	ms->gScreen->glPaintOutputSetEnabled (ms, true);
+	paint_rectangle = true;
+    }
+    else
+    {
+	ms->gScreen->glPaintOutputSetEnabled (ms, false);
+	paint_rectangle = false;
+    }
+
     if (ms->w)
     {
 	MOVE_WINDOW (ms->w);
 
+	if (ms->optionGetMode () != MoveOptions::ModeNormal) {
+	    ms->gScreen->glPaintOutputSetEnabled (ms, false);
+	    paint_rectangle = false;
+
+	    mw->window->move (pos_x, pos_y, true);
+	}
+
 	if (state & CompAction::StateCancel)
+	{
 	    ms->w->move (ms->savedX - ms->w->geometry ().x (),
 			 ms->savedY - ms->w->geometry ().y (), false);
+	}
 
 	/* update window attributes as window constraints may have
 	   changed - needed e.g. if a maximized window was moved
@@ -318,6 +353,7 @@
 
 	int wX      = w->geometry ().x ();
 	int wY      = w->geometry ().y ();
+
 	int wWidth  = w->geometry ().widthIncBorders ();
 	int wHeight = w->geometry ().heightIncBorders ();
 
@@ -522,8 +558,15 @@
 
 	if (dx || dy)
 	{
-	    w->move (wX + dx - w->geometry ().x (),
-		     wY + dy - w->geometry ().y (), false);
+	    if (ms->optionGetMode () == MoveOptions::ModeNormal)
+	    {
+		w->move (wX + dx - w->geometry ().x (), wY + dy - w->geometry ().y (), false);
+	    }
+	    else
+	    {
+		pos_x += wX + dx - w->geometry ().x ();
+		pos_y += wY + dy - w->geometry ().y ();
+	    }
 
 	    ms->x -= dx;
 	    ms->y -= dy;
@@ -534,6 +577,10 @@
 void
 MoveScreen::handleEvent (XEvent *event)
 {
+    Box box;
+    if (getMovingRectangle (&box))
+	damageMovingRectangle (&box);
+
     switch (event->type)
     {
 	case ButtonPress:
@@ -704,6 +751,7 @@
 MoveScreen::MoveScreen (CompScreen *screen) :
     PluginClassHandler<MoveScreen,CompScreen> (screen),
     cScreen (CompositeScreen::get (screen)),
+    gScreen (GLScreen::get (screen)),
     w (0),
     region (NULL),
     status (RectangleOut),
@@ -734,6 +782,18 @@
     optionSetInitiateKeyTerminate (moveTerminate);
 
     ScreenInterface::setHandler (screen);
+    GLScreenInterface::setHandler (gScreen);
+
+    if (optionGetMode () != MoveOptions::ModeNormal)
+    {
+	paint_rectangle = true;
+	gScreen->glPaintOutputSetEnabled (this, true);
+    }
+    else
+    {
+	paint_rectangle = false;
+	gScreen->glPaintOutputSetEnabled (this, false);
+    }
 }
 
 MoveScreen::~MoveScreen ()
@@ -743,6 +803,198 @@
 }
 
 bool
+MoveScreen::getMovingRectangle (BoxPtr pBox)
+{
+    if (optionGetMode () == MoveOptions::ModeNormal)
+	return false;
+
+    MOVE_SCREEN (screen);
+    if (!ms)
+	return false;
+
+    CompWindow *w = ms->w;
+    if (!w)
+	return false;
+
+    int wX      = w->geometry ().x () - w->border ().left;
+    int wY      = w->geometry ().y () - w->border ().top;
+    int wWidth  = w->geometry ().widthIncBorders ();
+    int wHeight = w->geometry ().heightIncBorders ();
+
+    pBox->x1 = wX + pos_x;
+    pBox->y1 = wY + pos_y;
+
+    pBox->x2 = pBox->x1 + wWidth;
+    pBox->y2 = pBox->y1 + wHeight;
+
+    return true;
+}
+
+bool MoveScreen::glPaintOutput (const GLScreenPaintAttrib &attrib,
+				const GLMatrix &transform,
+				const CompRegion &region,
+				CompOutput *output,
+				unsigned int mask)
+{
+    bool status = gScreen->glPaintOutput (attrib, transform, region, output, mask);
+
+    if (status && paint_rectangle)
+    {
+	unsigned short *borderColor = optionGetBorderColor ();
+	unsigned short *fillColor = optionGetFillColor ();
+
+	return glPaintMovingRectangle (transform, output, borderColor, (optionGetMode() == MoveOptions::ModeRectangle) ? fillColor : NULL);
+    }
+    return status;
+}
+
+void
+MoveScreen::damageMovingRectangle (BoxPtr pBox)
+{
+    int x1, x2, y1, y2;
+
+    x1 = pBox->x1 - 1;
+    y1 = pBox->y1 - 1;
+    x2 = pBox->x2 + 1;
+    y2 = pBox->y2 + 1;
+
+    if (cScreen)
+	cScreen->damageRegion (CompRect (x1, y1, x2 - x1, y2 - y1));
+}
+
+bool
+MoveScreen::glPaintMovingRectangle (const GLMatrix &transform,
+				    CompOutput *output,
+				    unsigned short *borderColor,
+				    unsigned short *fillColor)
+{
+    BoxRec box;
+    if (!getMovingRectangle(&box))
+	return false;
+
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+    GLMatrix sTransform (transform);
+
+    GLfloat vertexData[12];
+    GLfloat vertexData2[24];
+    GLushort fc[4], bc[4];
+    GLint origSrc, origDst;
+
+    bool blend = optionGetBlend ();
+    if (blend)
+    {
+#ifdef USE_GLES
+	GLint origSrcAlpha, origDstAlpha;
+	glGetIntegerv (GL_BLEND_SRC_RGB, &origSrc);
+	glGetIntegerv (GL_BLEND_DST_RGB, &origDst);
+	glGetIntegerv (GL_BLEND_SRC_ALPHA, &origSrcAlpha);
+	glGetIntegerv (GL_BLEND_DST_ALPHA, &origDstAlpha);
+#else
+	glGetIntegerv (GL_BLEND_SRC, &origSrc);
+	glGetIntegerv (GL_BLEND_DST, &origDst);
+#endif
+    }
+
+    bc[3] = (float) borderColor[3] / (float) 65535.0f;
+    bc[0] = ((float) borderColor[0] / 65535.0f) * bc[3];
+    bc[1] = ((float) borderColor[1] / 65535.0f) * bc[3];
+    bc[2] = ((float) borderColor[2] / 65535.0f) * bc[3];
+    if (!blend)
+	bc[3] = 1;
+
+    vertexData[0] = box.x1;
+    vertexData[1] = box.y1;
+    vertexData[2] = 0.0f;
+    vertexData[3] = box.x1;
+    vertexData[4] = box.y2;
+    vertexData[5] = 0.0f;
+    vertexData[6] = box.x2;
+    vertexData[7] = box.y1;
+    vertexData[8] = 0.0f;
+    vertexData[9] = box.x2;
+    vertexData[10] = box.y2;
+    vertexData[11] = 0.0f;
+
+    vertexData2[0] = box.x1;
+    vertexData2[1] = box.y1;
+    vertexData2[2] = 0.0f;
+    vertexData2[3] = box.x1;
+    vertexData2[4] = box.y2;
+    vertexData2[5] = 0.0f;
+    vertexData2[6] = box.x1;
+    vertexData2[7] = box.y2;
+    vertexData2[8] = 0.0f;
+    vertexData2[9] = box.x2;
+    vertexData2[10] = box.y2;
+    vertexData2[11] = 0.0f;
+    vertexData2[12] = box.x2;
+    vertexData2[13] = box.y2;
+    vertexData2[14] = 0.0f;
+    vertexData2[15] = box.x2;
+    vertexData2[16] = box.y1;
+    vertexData2[17] = 0.0f;
+    vertexData2[18] = box.x2;
+    vertexData2[19] = box.y1;
+    vertexData2[20] = 0.0f;
+    vertexData2[21] = box.x1;
+    vertexData2[22] = box.y1;
+    vertexData2[23] = 0.0f;
+
+    sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
+
+    if (blend)
+    {
+	glEnable (GL_BLEND);
+	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    }
+
+    /* fill rectangle */
+    if (fillColor)
+    {
+	fc[3] = fillColor[3];
+	fc[0] = fillColor[0] * (unsigned long) fc[3] / 65535;
+	fc[1] = fillColor[1] * (unsigned long) fc[3] / 65535;
+	fc[2] = fillColor[2] * (unsigned long) fc[3] / 65535;
+	if (!blend)
+	    fc[3] = 1;
+
+	streamingBuffer->begin (GL_TRIANGLE_STRIP);
+	streamingBuffer->addColors (1, fc);
+	streamingBuffer->addVertices (4, &vertexData[0]);
+	streamingBuffer->end ();
+	streamingBuffer->render (sTransform);
+    }
+
+    /* draw outline */
+    static const int borderWidth = 2;
+
+    glLineWidth (borderWidth);
+    streamingBuffer->begin (GL_LINES);
+    streamingBuffer->addColors (1, borderColor);
+    streamingBuffer->addVertices (8, &vertexData2[0]);
+    streamingBuffer->end ();
+    streamingBuffer->render (sTransform);
+
+    if (blend)
+    {
+	glEnable (GL_BLEND);
+	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    }
+
+    CompositeScreen *cScreen = CompositeScreen::get (screen);
+    if (cScreen)
+    {
+	CompRect damage (box.x1 - borderWidth,
+			 box.y1 - borderWidth,
+			 box.x2 - box.x1 + 2,
+			 box.y2 - box.y1 + 2);
+	cScreen->damageRegion (damage);
+    }
+
+    return true;
+}
+
+bool
 MovePluginVTable::init ()
 {
     if (CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))

=== modified file 'plugins/move/src/move.h'
--- plugins/move/src/move.h	2015-10-20 15:11:54 +0000
+++ plugins/move/src/move.h	2016-12-08 13:50:39 +0000
@@ -32,7 +32,6 @@
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 
-
 #define NUM_KEYS (sizeof (mKeys) / sizeof (mKeys[0]))
 
 struct _MoveKeys
@@ -49,6 +48,7 @@
 };
 
 class MoveScreen :
+    public GLScreenInterface,
     public ScreenInterface,
     public CompositeScreenInterface,
     public PluginClassHandler<MoveScreen,CompScreen>,
@@ -59,6 +59,7 @@
 	~MoveScreen ();
 
 	CompositeScreen *cScreen;
+	GLScreen *gScreen;
 
 	void updateOpacity ();
 
@@ -67,6 +68,16 @@
 	bool registerPaintHandler (compiz::composite::PaintHandler *pHnd);
 	void unregisterPaintHandler ();
 
+	bool glPaintOutput (const GLScreenPaintAttrib &,
+			    const GLMatrix &,
+			    const CompRegion &,
+			    CompOutput *,
+			    unsigned int);
+
+	bool getMovingRectangle (BoxPtr pbox);
+	void damageMovingRectangle (BoxPtr pbox);
+	bool glPaintMovingRectangle (const GLMatrix &transform, CompOutput *output, unsigned short *borderColor, unsigned short *fillColor);
+
 	CompWindow *w;
 	int        savedX;
 	int        savedY;