Merge lp:~smspillaz/unity/unity.oem-fixes into lp:unity/4.0

[David Barth]

Fix for bug #838128, which is on the OEM priority list.

[Robert Carr (robertcarr)]

+1. Though, I'm wondering if it should always be GL_LINEAR? Didn't we have a setting for that?

review: Approve

[Sam Spilsbury (smspillaz)]

It doesn't make sense to do texture filtering on the framebuffer object since its always painted on-screen at the same position and same size.

[Jason Smith (jassmith)]

style fixes:
- please make sure to use brackets around all loops (for loops especially)

GL changes:
There is no reason to disable the scissor bit if you are going to pop the attrib right afterwards. Small change though I remember we ran into another weird state issue not long ago. I can't remember what exactly it was but it was something similar to this (multiple changes to the same bit in a row for no reason)

Please check the result of glGetError

review: Approve

[Sam Spilsbury (smspillaz)]

done

[Daniel van Vugt (vanvugt)]

For the record, this proposal also contains the fixes for bug 861061 and bug 880707. This is because Sam's branches copied the fix from lp:~vanvugt/unity/fix-861061-trunk

=== modified file 'plugins/unityshell/src/BackgroundEffectHelper.cpp'
--- plugins/unityshell/src/BackgroundEffectHelper.cpp	2011-09-28 05:19:39 +0000
+++ plugins/unityshell/src/BackgroundEffectHelper.cpp	2012-01-05 02:50:46 +0000
@@ -85,7 +85,20 @@
 bool BackgroundEffectHelper::HasEnabledHelpers()
 {
   for (BackgroundEffectHelper * bg_effect_helper : registered_list_)
+  {
     if (bg_effect_helper->enabled)
+    {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool BackgroundEffectHelper::HasDirtyHelpers()
+{
+  for (BackgroundEffectHelper * bg_effect_helper : registered_list_)
+    if (bg_effect_helper->enabled && bg_effect_helper->cache_dirty)
       return true;
 
   return false;
 
=== modified file 'plugins/unityshell/src/BackgroundEffectHelper.h'
--- plugins/unityshell/src/BackgroundEffectHelper.h	2011-09-21 02:52:26 +0000
+++ plugins/unityshell/src/BackgroundEffectHelper.h	2012-01-05 02:50:46 +0000
@@ -54,7 +54,7 @@
   void DirtyCache();
 
   static void ProcessDamage(nux::Geometry geo);
-
+  static bool HasDirtyHelpers();
   static bool HasEnabledHelpers();
 
   static nux::Property<unity::BlurType> blur_type;
 
=== modified file 'plugins/unityshell/src/PanelView.cpp'
--- plugins/unityshell/src/PanelView.cpp	2011-10-13 16:56:43 +0000
+++ plugins/unityshell/src/PanelView.cpp	2012-01-05 02:50:46 +0000
@@ -604,8 +604,7 @@
 
   _opacity = opacity;
 
-  if (_opacity < 1.0f && !_dash_is_open)
-    bg_effect_helper_.enabled = false;
+  bg_effect_helper_.enabled = (_opacity < 1.0f || _dash_is_open);
 
   ForceUpdateBackground();
 }
 
=== added file 'plugins/unityshell/src/ScreenEffectFramebufferObject.cpp'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-01-05 02:50:46 +0000
@@ -0,0 +1,234 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * 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 3
+ * 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.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include "ScreenEffectFramebufferObject.h"
+#include "BackgroundEffectHelper.h"
+#include <NuxCore/Logger.h>
+#include <dlfcn.h>
+
+namespace
+{
+  nux::logging::Logger logger ("unity.screeneffectframebufferobject");
+}
+
+void ScreenEffectFramebufferObject::paint (const nux::Geometry &output)
+{
+  /* Draw the bit of the relevant framebuffer for each output */
+
+  glPushAttrib (GL_VIEWPORT_BIT);
+  glViewport (0, mScreenSize.height - (output.y + output.height), mScreenSize.width, mScreenSize.height);
+
+  if (mFBTexture)
+  {
+    glEnable (GL_TEXTURE_2D);
+    activeTexture (GL_TEXTURE0_ARB);
+    glBindTexture (GL_TEXTURE_2D, mFBTexture);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    glPushAttrib (GL_SCISSOR_BIT);
+    glEnable (GL_SCISSOR_TEST);
+
+    glScissor (output.x, mScreenSize.height - (output.y + output.height),
+	       output.width, output.height);
+
+    /* FIXME: This needs to be GL_TRIANGLE_STRIP */
+    glBegin (GL_QUADS);
+    glTexCoord2f (0, 1);
+    glVertex2i   (mGeometry.x, mGeometry.y);
+    glTexCoord2f (0, 0);
+    glVertex2i   (mGeometry.x, mGeometry.y + mGeometry.height);
+    glTexCoord2f (1, 0);
+    glVertex2i   (mGeometry.x + mGeometry.width, mGeometry.y + mGeometry.height);
+    glTexCoord2f (1, 1);
+    glVertex2i   (mGeometry.x + mGeometry.width, mGeometry.y);
+    glEnd ();
+
+    activeTexture (GL_TEXTURE0_ARB);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glBindTexture (GL_TEXTURE_2D, 0);
+    glDisable (GL_TEXTURE_2D);
+    glPopAttrib ();
+  }
+  glPopAttrib ();
+}
+
+void ScreenEffectFramebufferObject::onScreenSizeChanged(const nux::Geometry& screenSize)
+{
+  mScreenSize = screenSize;
+}
+
+
+void ScreenEffectFramebufferObject::unbind ()
+{
+  if (!mBoundCnt)
+    return;
+
+  mBoundCnt--;
+
+  (*bindFramebuffer) (GL_FRAMEBUFFER_EXT, 0);
+
+  glDrawBuffer (GL_BACK);
+  glReadBuffer (GL_BACK);
+
+  /* Matches the viewport set we did in ::bind () */
+  glPopAttrib ();
+
+}
+
+bool ScreenEffectFramebufferObject::status ()
+{
+  return mFboStatus;
+}
+
+void ScreenEffectFramebufferObject::bind (const nux::Geometry &output)
+{
+  if (!BackgroundEffectHelper::HasDirtyHelpers())
+    return;
+
+  /* Clear the error bit */
+  glGetError ();
+
+  if (!mFBTexture)
+  {
+    glGenTextures (1, &mFBTexture);
+
+    glBindTexture (GL_TEXTURE_2D, mFBTexture);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, mGeometry.width, mGeometry.height, 0, GL_BGRA,
+#if IMAGE_BYTE_ORDER == MSBFirst
+                 GL_UNSIGNED_INT_8_8_8_8_REV,
+#else
+                 GL_UNSIGNED_BYTE,
+#endif
+                 NULL);
+
+    glBindTexture (GL_TEXTURE_2D, 0);
+
+    if (glGetError () != GL_NO_ERROR)
+    {
+      mFboHandle = 0;
+      mFboStatus = false;
+      return;
+    }
+  }
+
+  (*bindFramebuffer) (GL_FRAMEBUFFER_EXT, mFboHandle);
+
+  (*framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                               GL_TEXTURE_2D, mFBTexture, 0);
+
+  (*framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
+                               GL_TEXTURE_2D, 0, 0);
+
+  /* Ensure that a framebuffer is actually available */
+  if (!mFboStatus)
+  {
+    GLint status = (*checkFramebufferStatus) (GL_DRAW_FRAMEBUFFER);
+
+    if (status != GL_FRAMEBUFFER_COMPLETE)
+    {
+      switch (status)
+      {
+        case GL_FRAMEBUFFER_UNDEFINED:
+          LOG_WARN (logger) <<  "no window";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+          LOG_WARN (logger) <<  "attachment incomplete";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+          LOG_WARN (logger) <<  "no buffers attached to fbo";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
+          LOG_WARN (logger) <<  "some attachment in glDrawBuffers doesn't exist in FBO";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
+          LOG_WARN (logger) <<  "some attachment in glReadBuffers doesn't exist in FBO";
+          break;
+        case GL_FRAMEBUFFER_UNSUPPORTED:
+          LOG_WARN (logger) <<  "unsupported internal format";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+          LOG_WARN (logger) <<  "different levels of sampling for each attachment";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
+          LOG_WARN (logger) <<  "number of layers is different";
+          break;
+        default:
+          LOG_WARN (logger) <<  "unable to bind the framebuffer for an unknown reason";
+          break;
+      }
+
+      bindFramebuffer (GL_FRAMEBUFFER_EXT, 0);
+      deleteFramebuffers (1, &mFboHandle);
+
+      glDrawBuffer (GL_BACK);
+      glReadBuffer (GL_BACK);
+
+      mFboHandle = 0;
+
+      mFboStatus = false;
+    }
+    else
+      mFboStatus = true;
+  }
+
+  if (mFboStatus)
+  {
+    glPushAttrib (GL_VIEWPORT_BIT);
+
+    glViewport (output.x,
+	       mScreenSize.height - (output.y + output.height),
+	       output.width,
+	       output.height);
+  }
+
+  mBoundCnt++;
+}
+
+
+ScreenEffectFramebufferObject::ScreenEffectFramebufferObject (GLXGetProcAddressProc p, const nux::Geometry &geom)
+ : getProcAddressGLX (p)
+ , mFboStatus (false)
+ , mFBTexture (0)
+ , mGeometry (geom)
+ , mBoundCnt (0)
+ , mScreenSize (geom)
+{
+  activeTexture = (GLActiveTextureProc) (*getProcAddressGLX) ((GLubyte *) "glActiveTexture");
+  genFramebuffers = (GLGenFramebuffersProc) (*getProcAddressGLX) ((GLubyte *)"glGenFramebuffersEXT");
+  deleteFramebuffers = (GLDeleteFramebuffersProc) (*getProcAddressGLX) ((GLubyte *)"glDeleteFramebuffersEXT");
+  bindFramebuffer = (GLBindFramebufferProc) (*getProcAddressGLX) ((GLubyte *)"glBindFramebufferEXT");
+  checkFramebufferStatus = (GLCheckFramebufferStatusProc) (*getProcAddressGLX) ((GLubyte *) "glCheckFramebufferStatusEXT");
+  framebufferTexture2D = (GLFramebufferTexture2DProc) (*getProcAddressGLX) ((GLubyte *) "glFramebufferTexture2DEXT");
+  
+  (*genFramebuffers) (1, &mFboHandle);
+}
+
+ScreenEffectFramebufferObject::~ScreenEffectFramebufferObject ()
+{
+  (*deleteFramebuffers) (1, &mFboHandle);
+
+  if (mFBTexture)
+    glDeleteTextures (1, &mFBTexture);
+}
 
=== added file 'plugins/unityshell/src/ScreenEffectFramebufferObject.h'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.h	2012-01-05 02:50:46 +0000
@@ -0,0 +1,84 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * 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 3
+ * 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.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#ifndef UNITY_SCREENEFFECT_FRAMEBUFFER_H
+#define UNITY_SCREENEFFECT_FRAMEBUFFER_H
+
+#include <Nux/Nux.h>
+
+class ScreenEffectFramebufferObject
+{
+public:
+
+  typedef boost::shared_ptr <ScreenEffectFramebufferObject> Ptr;
+  typedef void (*FuncPtr) (void);
+  typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
+
+  ScreenEffectFramebufferObject (GLXGetProcAddressProc, const nux::Geometry &geom);
+  ~ScreenEffectFramebufferObject ();
+
+public:
+
+  void bind (const nux::Geometry &geom);
+  void unbind ();
+
+  bool status ();
+  void paint (const nux::Geometry &geom);
+  bool bound () { return mBoundCnt > 0; }
+
+  GLuint texture () { return mFBTexture; }
+  
+  void onScreenSizeChanged (const nux::Geometry &screenSize);
+
+private:
+
+  FuncPtr getProcAddr (const std::string &);
+
+  typedef void (*GLActiveTextureProc) (GLenum texture);
+  typedef void (*GLGenFramebuffersProc) (GLsizei n,
+                                         GLuint  *framebuffers);
+  typedef void (*GLDeleteFramebuffersProc) (GLsizei n,
+                                            GLuint  *framebuffers);
+  typedef void (*GLBindFramebufferProc) (GLenum target,
+                                         GLuint framebuffer);
+  typedef GLenum (*GLCheckFramebufferStatusProc) (GLenum target);
+  typedef void (*GLFramebufferTexture2DProc) (GLenum target,
+                                              GLenum attachment,
+                                              GLenum textarget,
+                                              GLuint texture,
+                                              GLint  level);
+  
+  GLXGetProcAddressProc getProcAddressGLX;
+  GLActiveTextureProc activeTexture;
+  GLGenFramebuffersProc genFramebuffers;
+  GLDeleteFramebuffersProc deleteFramebuffers;
+  GLBindFramebufferProc bindFramebuffer;
+  GLCheckFramebufferStatusProc checkFramebufferStatus;
+  GLFramebufferTexture2DProc framebufferTexture2D;
+  /* compiz fbo handle that goes through to nux */
+  GLuint   mFboHandle; // actual handle to the framebuffer_ext
+  bool    mFboStatus; // did the framebuffer texture bind succeed
+  GLuint   mFBTexture;
+  nux::Geometry mGeometry;
+  unsigned int mBoundCnt;
+  
+  nux::Geometry mScreenSize;
+};
+
+#endif
 
=== modified file 'plugins/unityshell/src/comptransientfor.cpp'
--- plugins/unityshell/src/comptransientfor.cpp	2011-12-15 15:14:48 +0000
+++ plugins/unityshell/src/comptransientfor.cpp	2012-01-05 02:50:46 +0000
@@ -57,6 +57,8 @@
 {
   if (!ancestor ||
       !priv->mWindow->id ())
+    return false;
+
   return priv->mWindow->transientFor () == ancestor;
 }
 
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2011-12-15 16:05:39 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-01-05 02:50:46 +0000
@@ -111,8 +111,7 @@
   , damaged(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
-  , switcher_desktop_icon(nullptr)
-  , mActiveFbo (0)
+  , _active_fbo (0)
   , dash_is_open_ (false)
   , grab_index_ (0)
   , painting_tray_ (false)
@@ -225,12 +224,21 @@
      _edge_timeout = optionGetLauncherRevealEdgeTimeout ();
      _in_paint = false;
 
+    void *dlhand = dlopen ("libunityshell.so", RTLD_LAZY);
+
+    if (dlhand)
+    {
+      dlerror ();
+      glXGetProcAddressP = (ScreenEffectFramebufferObject::GLXGetProcAddressProc) dlsym (dlhand, "glXGetProcAddress");
+      if (dlerror () != NULL)
+        glXGetProcAddressP = NULL;
+    }
+
      if (GL::fbo)
      {
-       foreach (CompOutput & o, screen->outputDevs())
-	     uScreen->mFbos[&o] = UnityFBO::Ptr (new UnityFBO(&o));
-
-       uScreen->mFbos[&(screen->fullscreenOutput ())] = UnityFBO::Ptr (new UnityFBO(&(screen->fullscreenOutput ())));
+       nux::Geometry geometry (0, 0, screen->width (), screen->height ());
+       uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+       uScreen->_fbo->onScreenSizeChanged (geometry);
      }
 
      optionSetLauncherHideModeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -451,7 +459,7 @@
 
 void UnityScreen::nuxEpilogue()
 {
-  (*GL::bindFramebuffer)(GL_FRAMEBUFFER_EXT, mActiveFbo);
+  (*GL::bindFramebuffer)(GL_FRAMEBUFFER_EXT, _active_fbo);
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
@@ -492,8 +500,6 @@
   if (PluginAdapter::Default()->IsExpoActive())
     return;
 
-  nuxPrologue();
-
   CompOutput* output = _last_output;
   float vc[4];
   float h = 20.0f;
@@ -504,6 +510,9 @@
   float y1 = output->y() + panel_h;
   float x2 = x1 + output->width();
   float y2 = y1 + h;
+  GLMatrix sTransform = GLMatrix ();
+
+  sTransform.toScreenSpace(output, -DEFAULT_Z_CAMERA);
 
   vc[0] = x1;
   vc[1] = x2;
@@ -543,7 +552,6 @@
       glDisable(GL_BLEND);
     }
   }
-  nuxEpilogue();
 }
 
 void
@@ -562,30 +570,35 @@
 {
   CompOutput *output = _last_output;
   Window     tray_xid = panelController->GetTrayXid ();
-  bool       bound = mFbos[output]->bound ();
-
-
-  if (bound)
+
+  bool was_bound = _fbo->bound ();
+  _fbo->unbind ();
+
+  /* Draw the bit of the relevant framebuffer for each output */
+
+  if (was_bound)
   {
-    mFbos[output]->unbind ();
-
-    /* Draw the bit of the relevant framebuffer for each output */
-    mFbos[output]->paint ();
+    GLMatrix sTransform;
+    sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
+    glPushMatrix ();
+    glLoadMatrixf (sTransform.getMatrix ());
+    _fbo->paint (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
+    glPopMatrix ();
   }
 
-  nuxPrologue();
-
   nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture =
-  nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(mFbos[output]->texture(),
-  output->width(), output->height(), 1, nux::BITFMT_R8G8B8A8);
+      nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(_fbo->texture(),
+                                                                       screen->width (), screen->height(), 1, nux::BITFMT_R8G8B8A8);
 
   nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
 
-  nux::Geometry geo = nux::Geometry (output->x (), output->y (), output->width (), output->height ());
+  nux::Geometry geo = nux::Geometry (0, 0, screen->width (), screen->height ());
+  nux::Geometry oGeo = nux::Geometry (output->x (), output->y (), output->width (), output->height ());
   BackgroundEffectHelper::monitor_rect_ = geo;
 
+  nuxPrologue();
   _in_paint = true;
-  wt->RenderInterfaceFromForeignCmd (&geo);
+  wt->RenderInterfaceFromForeignCmd (&oGeo);
   _in_paint = false;
   nuxEpilogue();
 
@@ -985,6 +998,10 @@
 {
   bool ret;
 
+  doShellRepaint = true;
+  allowWindowPaint = true;
+  _last_output = output;
+
   /* bind the framebuffer here
    * - it will be unbound and flushed
    *   to the backbuffer when some
@@ -995,11 +1012,7 @@
    *   attempts to bind it will only increment
    *   its bind reference so make sure that
    *   you always unbind as much as you bind */
-  mFbos[output]->bind ();
-
-  doShellRepaint = true;
-  allowWindowPaint = true;
-  _last_output = output;
+  _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
 
   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
   ret = gScreen->glPaintOutput(attrib, transform, region, output, mask);
@@ -1154,16 +1167,37 @@
   {
     XDamageNotifyEvent *de = (XDamageNotifyEvent *) event;
     CompWindow* w = screen->findWindow (de->drawable);
+    std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
+    CompWindow* lastNWindow = screen->findWindow (xwns.back ());
+    bool        processDamage = true;
 
     if (w)
     {
-      nux::Geometry damage (de->area.x, de->area.y, de->area.width, de->area.height);
-
-      CompWindow::Geometry geom = w->geometry ();
-      damage.x += geom.x () + geom.border ();
-      damage.y += geom.y () + geom.border ();
-
-      BackgroundEffectHelper::ProcessDamage(damage);
+      if (!w->overrideRedirect () &&
+          w->isViewable () &&
+          !w->invisible ())
+      {
+
+        for (; lastNWindow != NULL; lastNWindow = lastNWindow->next)
+        {
+          if (lastNWindow == w)
+          {
+            processDamage = false;
+            break;
+          }
+        }
+
+        if (processDamage)
+        {
+          nux::Geometry damage (de->area.x, de->area.y, de->area.width, de->area.height);
+
+          const CompWindow::Geometry &geom = w->geometry ();
+          damage.x += geom.x () + geom.border ();
+          damage.y += geom.y () + geom.border ();
+
+          BackgroundEffectHelper::ProcessDamage(damage);
+        }
+      }
     }
   }
 }
@@ -2146,16 +2180,15 @@
   GdkRectangle rect;
   nux::Geometry lCurGeom;
   int panel_height = 24;
+  nux::Geometry geometry (0, 0, screen->width (), screen->height ());
 
   if (!needsRelayout)
     return;
 
   if (GL::fbo)
   {
-    foreach (CompOutput &o, screen->outputDevs ())
-      uScreen->mFbos[&o] = UnityFBO::Ptr (new UnityFBO (&o));
-
-    uScreen->mFbos[&(screen->fullscreenOutput ())] = UnityFBO::Ptr (new UnityFBO (&(screen->fullscreenOutput ())));
+    uScreen->_fbo.reset (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+    uScreen->_fbo->onScreenSizeChanged (geometry);
   }
 
   UScreen *uscreen = UScreen::GetDefault();
@@ -2194,8 +2227,6 @@
 {
   UnityScreen* uScr = reinterpret_cast<UnityScreen*>(data);
 
-  uScreen->mFbos.clear ();
-
   uScr->NeedsRelayout ();
   uScr->Relayout();
   uScr->relayoutSourceId = 0;
@@ -2228,220 +2259,6 @@
   ScheduleRelayout(500);
 }
 
-void UnityFBO::paint ()
-{
-  //CompositeScreen *cScreen = CompositeScreen::get (screen);
-  //unsigned int    mask = cScreen->damageMask ();
-  float texx, texy, texwidth, texheight;
-
-  /* Must be completely unbound before painting */
-  if (mBoundCnt)
-    return;
-
-  /* Draw the bit of the relevant framebuffer for each output */
-  GLMatrix transform;
-
-  glViewport (output->x (), screen->height () - output->y2 (), output->width (), output->height ());
-  GLScreen::get (screen)->clearOutput (output, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-  transform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
-  glPushMatrix ();
-  glLoadMatrixf (transform.getMatrix ());
-
-  /* Note that texcoords here are normalized, so it's just (0,0)-(1,1) */
-  texx = 0.0;
-  texy = 0.0;
-  texwidth = 1.0f;
-  texheight = 1.0f;
-
-  if (mFBTexture)
-  {
-    glEnable (GL_TEXTURE_2D);
-    GL::activeTexture (GL_TEXTURE0_ARB);
-    glBindTexture (GL_TEXTURE_2D, mFBTexture);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-    glPushAttrib (GL_SCISSOR_BIT);
-    glEnable (GL_SCISSOR_TEST);
-
-    glScissor (output->x1 (), screen->height () - output->y2 (),
-               output->width (), output->height ());
-
-    /* FIXME: This needs to be GL_TRIANGLE_STRIP */
-    glBegin (GL_QUADS);
-    glTexCoord2f (texx, texy + texheight);
-    glVertex2i   (output->x1 (), output->y1 ());
-    glTexCoord2f (texx, texy);
-    glVertex2i   (output->x1 (), output->y2 ());
-    glTexCoord2f (texx + texwidth, texy);
-    glVertex2i   (output->x2 (), output->y2 ());
-    glTexCoord2f (texx + texwidth, texy + texheight);
-    glVertex2i   (output->x2 (),  output->y1 ());
-    glEnd ();
-
-    GL::activeTexture (GL_TEXTURE0_ARB);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glBindTexture (GL_TEXTURE_2D, 0);
-    glEnable (GL_TEXTURE_2D);
-
-    glDisable (GL_SCISSOR_TEST);
-    glPopAttrib ();
-  }
-
-  glPopMatrix();
-}
-
-void UnityFBO::unbind ()
-{
-  mBoundCnt--;
-
-  if (mBoundCnt)
-    return;
-
-  uScreen->setActiveFbo (0);
-  (*GL::bindFramebuffer) (GL_FRAMEBUFFER_EXT, 0);
-
-  glDrawBuffer (GL_BACK);
-  glReadBuffer (GL_BACK);
-
-}
-
-bool UnityFBO::bound ()
-{
-  return mBoundCnt > 0;
-}
-
-bool UnityFBO::status ()
-{
-  return mFboStatus;
-}
-
-void UnityFBO::bind ()
-{
-  if (mBoundCnt)
-  {
-    mBoundCnt++;
-    return;
-  }
-
-  if (!mFBTexture)
-  {
-    glGenTextures (1, &mFBTexture);
-
-    glBindTexture (GL_TEXTURE_2D, mFBTexture);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, output->width(), output->height(), 0, GL_BGRA,
-#if IMAGE_BYTE_ORDER == MSBFirst
-                 GL_UNSIGNED_INT_8_8_8_8_REV,
-#else
-                 GL_UNSIGNED_BYTE,
-#endif
-                 NULL);
-
-    glBindTexture (GL_TEXTURE_2D, 0);
-  }
-
-  glGetError ();
-
-  (*GL::bindFramebuffer) (GL_FRAMEBUFFER_EXT, mFboHandle);
-
-  (*GL::framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
-                               GL_TEXTURE_2D, mFBTexture, 0);
-
-  (*GL::framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
-                               GL_TEXTURE_2D, 0, 0);
-
-  /* Ensure that a framebuffer is actually available */
-  if (!mFboStatus)
-  {
-    GLint status = (*GL::checkFramebufferStatus) (GL_DRAW_FRAMEBUFFER);
-
-    if (status != GL_FRAMEBUFFER_COMPLETE)
-    {
-      switch (status)
-      {
-        case GL_FRAMEBUFFER_UNDEFINED:
-          compLogMessage ("unity", CompLogLevelWarn, "no window");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
-          compLogMessage ("unity", CompLogLevelWarn, "attachment incomplete");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
-          compLogMessage ("unity", CompLogLevelWarn, "no buffers attached to fbo");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
-          compLogMessage ("unity", CompLogLevelWarn, "some attachment in glDrawBuffers doesn't exist in FBO");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
-          compLogMessage ("unity", CompLogLevelWarn, "some attachment in glReadBuffers doesn't exist in FBO");
-          break;
-        case GL_FRAMEBUFFER_UNSUPPORTED:
-          compLogMessage ("unity", CompLogLevelWarn, "unsupported internal format");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
-          compLogMessage ("unity", CompLogLevelWarn, "different levels of sampling for each attachment");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
-          compLogMessage ("unity", CompLogLevelWarn, "number of layers is different");
-          break;
-        default:
-          compLogMessage ("unity", CompLogLevelWarn, "unable to bind the framebuffer for an unknown reason");
-          break;
-      }
-
-      GL::bindFramebuffer (GL_FRAMEBUFFER_EXT, 0);
-      GL::deleteFramebuffers (1, &mFboHandle);
-
-      glDrawBuffer (GL_BACK);
-      glReadBuffer (GL_BACK);
-
-      mFboHandle = 0;
-
-      mFboStatus = false;
-      uScreen->setActiveFbo (0);
-    }
-    else
-      mFboStatus = true;
-  }
-
-  if (mFboStatus)
-  {
-    uScreen->setActiveFbo (mFboHandle);
-
-    glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
-    glReadBuffer (GL_COLOR_ATTACHMENT0_EXT);
-
-    glViewport (0,
-               0,
-               output->width(),
-               output->height());
-
-    mBoundCnt++;
-  }
-}
-
-UnityFBO::UnityFBO (CompOutput *o)
- : mFboStatus (false)
- , mFBTexture (0)
- , output (o)
- , mBoundCnt (0)
-{
-  (*GL::genFramebuffers) (1, &mFboHandle);
-}
-
-UnityFBO::~UnityFBO ()
-{
-  (*GL::deleteFramebuffers) (1, &mFboHandle);
-
-  if (mFBTexture)
-    glDeleteTextures (1, &mFBTexture);
-}
-
 void UnityScreen::OnDashRealized ()
 {
   /* stack any windows named "onboard" above us */
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2011-12-15 15:17:39 +0000
+++ plugins/unityshell/src/unityshell.h	2012-01-05 02:50:46 +0000
@@ -45,42 +45,14 @@
 #include <Nux/WindowThread.h>
 #include <sigc++/sigc++.h>
 #include <boost/shared_ptr.hpp>
+#include "ScreenEffectFramebufferObject.h"
 
 #include "compizminimizedwindowhandler.h"
-
-class UnityFBO
-{
-public:
-
-  typedef boost::shared_ptr <UnityFBO> Ptr;
-
-  UnityFBO (CompOutput *o);
-  ~UnityFBO ();
-
-public:
-
-  void bind ();
-  void unbind ();
-
-  bool status ();
-  bool bound ();
-  void paint ();
-
-  GLuint texture () { return mFBTexture; }
-
-private:
-
-  /* compiz fbo handle that goes through to nux */
-  GLuint   mFboHandle; // actual handle to the framebuffer_ext
-  bool    mFboStatus; // did the framebuffer texture bind succeed
-  GLuint   mFBTexture;
-  CompOutput *output;
-  unsigned int mBoundCnt;
-};
+#include <dlfcn.h>
 
 class UnityShowdesktopHandler
 {
-public:
+ public:
 
   UnityShowdesktopHandler (CompWindow *w);
   ~UnityShowdesktopHandler ();
@@ -240,8 +212,6 @@
   void NeedsRelayout();
   void ScheduleRelayout(guint timeout);
 
-  void setActiveFbo (GLuint fbo) { mActiveFbo = fbo; }
-
   bool forcePaintOnTop ();
 
 protected:
@@ -329,8 +299,8 @@
 
   unity::BGHash _bghash;
 
-  std::map <CompOutput *, UnityFBO::Ptr> mFbos;
-  GLuint                                 mActiveFbo;
+  ScreenEffectFramebufferObject::Ptr _fbo;
+  GLuint                             _active_fbo;
 
   bool   queryForShader ();
 
@@ -341,6 +311,8 @@
   bool                   painting_tray_;
   unsigned int           tray_paint_mask_;
 
+  ScreenEffectFramebufferObject::GLXGetProcAddressProc glXGetProcAddressP;
+
   friend class UnityWindow;
 };
 
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2011-10-04 12:15:09 +0000
+++ tests/CMakeLists.txt	2012-01-05 02:50:46 +0000
@@ -481,6 +481,20 @@
                )
 add_dependencies (test-bg-hash unity-core-${UNITY_API_VERSION})
 
+find_package (OpenGL)
+
+include_directories (${OPENGL_gl_INCDIRS})
+add_library (glfuncloader SHARED
+	     ${CMAKE_CURRENT_SOURCE_DIR}/GLFuncLoader.cpp)
+target_link_libraries (glfuncloader dl ${OPENGL_gl_LIBRARY})
+add_executable (screen-effect-fbo
+		TestScreenEffectFramebufferObject.cpp
+		${UNITY_SRC}/ScreenEffectFramebufferObject.cpp
+		${UNITY_SRC}/BackgroundEffectHelper.cpp)
+
+target_link_libraries (screen-effect-fbo glfuncloader ${OPENGL_gl_LIBRARY})
+add_dependencies (screen-effect-fbo unity-core-${UNITY_API_VERSION})
+
 add_subdirectory (test-input-remover)
 add_subdirectory (test-minimize-window-handler)
 add_subdirectory (test-get-transients)
 
=== added file 'tests/GLFuncLoader.cpp'
--- tests/GLFuncLoader.cpp	1970-01-01 00:00:00 +0000
+++ tests/GLFuncLoader.cpp	2012-01-05 02:50:46 +0000
@@ -0,0 +1,51 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * 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 3
+ * 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.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include "GLFuncLoader.h"
+#include <dlfcn.h>
+
+unity::GLLoader::FuncPtr unity::GLLoader::getProcAddr(const std::string &name)
+{
+  static void *dlhand = NULL;
+  FuncPtr funcPtr = NULL;
+
+  glGetError ();
+
+  if (!funcPtr)
+  {
+    if (!dlhand)
+      dlhand = dlopen ("libglfuncloader.so", RTLD_LAZY);
+
+    char *error =  dlerror ();
+
+    if (dlhand)
+    {
+      dlerror ();
+      funcPtr = (FuncPtr) dlsym (dlhand, name.c_str ());
+
+      error = dlerror ();
+      if (error != NULL)
+        funcPtr = NULL;
+    }
+  }
+
+  return funcPtr;
+}
+
+
 
=== added file 'tests/GLFuncLoader.h'
--- tests/GLFuncLoader.h	1970-01-01 00:00:00 +0000
+++ tests/GLFuncLoader.h	2012-01-05 02:50:46 +0000
@@ -0,0 +1,33 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * 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 3
+ * 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.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include <string>
+#include <GL/gl.h>
+#include <GL/glx.h>
+
+namespace unity
+{
+namespace GLLoader
+{
+typedef void (*FuncPtr) (void);
+typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
+
+FuncPtr getProcAddr(const std::string &name);
+}
+}
 
=== added file 'tests/TestScreenEffectFramebufferObject.cpp'
--- tests/TestScreenEffectFramebufferObject.cpp	1970-01-01 00:00:00 +0000
+++ tests/TestScreenEffectFramebufferObject.cpp	2012-01-05 02:50:46 +0000
@@ -0,0 +1,671 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * 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 3
+ * 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.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include "ScreenEffectFramebufferObject.h"
+#include "BackgroundEffectHelper.h"
+#include "GLFuncLoader.h"
+#include <Nux/Nux.h>
+#include <Nux/VLayout.h>
+#include <Nux/View.h>
+#include <Nux/BaseWindow.h>
+#include <Nux/WindowCompositor.h>
+#include <NuxCore/Logger.h>
+#include <NuxCore/Object.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <dlfcn.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <cmath>
+
+using namespace unity::GLLoader;
+
+namespace
+{
+  nux::logging::Logger logger ("unity.test-screeneffectframebufferobject");
+
+  const static int attributes[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT,
+                                    GLX_X_RENDERABLE, True,
+                                    GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+                                    GLX_DOUBLEBUFFER, True,
+                                    GLX_RED_SIZE, 8,
+                                    GLX_GREEN_SIZE, 8,
+                                    GLX_BLUE_SIZE, 8, 0};
+}
+
+namespace GLFuncs
+{
+  GLXGetProcAddressProc           glXGetProcAddressP;
+  PFNGLXCHOOSEFBCONFIGPROC        glXChooseFBConfigP;
+  PFNGLXGETVISUALFROMFBCONFIGPROC glXGetVisualFromFBConfigP;
+  PFNGLXCREATEWINDOWPROC          glXCreateWindowP;
+  PFNGLXDESTROYWINDOWPROC         glXDestroyWindowP;
+  PFNGLXMAKECONTEXTCURRENTPROC    glXMakeContextCurrentP;
+
+  void init ()
+  {
+    glXGetProcAddressP = (GLXGetProcAddressProc) getProcAddr ("glXGetProcAddress");
+    glXChooseFBConfigP = (PFNGLXCHOOSEFBCONFIGPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXChooseFBConfig");
+    glXGetVisualFromFBConfigP = (PFNGLXGETVISUALFROMFBCONFIGPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXGetVisualFromFBConfig");
+    glXCreateWindowP = (PFNGLXCREATEWINDOWPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXCreateWindow");
+    glXMakeContextCurrentP = (PFNGLXMAKECONTEXTCURRENTPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXMakeContextCurrent");
+    glXDestroyWindowP      = (PFNGLXDESTROYWINDOWPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXDestroyWindow");
+  }
+}
+
+class EffectView :
+  public nux::View
+{
+public:
+  EffectView (NUX_FILE_LINE_PROTO);
+  virtual ~EffectView ();
+
+  void Draw (nux::GraphicsEngine &context, bool force) { return; };
+  void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
+private:
+  BackgroundEffectHelper bg_effect_helper_;
+};
+
+class Shape
+{
+  public:
+
+    typedef boost::shared_ptr <Shape> Ptr;
+
+    Shape ();
+    virtual ~Shape ();
+
+    float rotation () { return mRotation; }
+
+    void draw (unsigned int width, unsigned int height) { glDraw (width, height); }
+    void rotate () { applyRotation (); }
+
+  protected:
+
+    float mRotation;
+
+    virtual void glDraw (unsigned int width, unsigned int height) = 0;
+    virtual void applyRotation () = 0;
+    virtual void getRotationAxes (float &x, float &y, float &z) = 0;
+};
+
+Shape::Shape () :
+ mRotation (0.0f)
+{
+}
+
+Shape::~Shape ()
+{
+}
+
+class Triangle :
+  public Shape
+{
+  public:
+
+    typedef boost::shared_ptr <Triangle> Ptr;
+
+  protected:
+
+    void glDraw (unsigned int width, unsigned int height);
+    void applyRotation () { mRotation += 5.0f; }
+    void getRotationAxes (float &x, float &y, float &z) { x = 0.0f; y = 1.0f; z = 0.0f; }
+};
+
+void
+Triangle::glDraw (unsigned int width, unsigned int height)
+{
+  glBegin(GL_TRIANGLES);
+      glColor3f(1.0f, 0.0f, 0.0f);
+      glVertex3f(width / 4, height, 0.0f);
+      glColor3f(0.0f, 1.0f, 0.0f);
+      glVertex3f(0.0f, 0.0f, 0.0f);
+      glColor3f(0.0f, 0.0f, 1.0f);
+      glVertex3f(width / 2, 0.0f, 0.0f);
+  glEnd();
+}
+
+class Square :
+  public Shape
+{
+  public:
+
+    typedef boost::shared_ptr <Square> Ptr;
+
+  protected:
+
+    void glDraw (unsigned int width, unsigned int height);
+    void applyRotation () { mRotation -= 2.5f; }
+    void getRotationAxes (float &x, float &y, float &z) { x = 1.0f; y = 0.0f; z = 0.0f; }
+    
+};
+
+void
+Square::glDraw (unsigned int width, unsigned int height)
+{
+  glBegin(GL_QUADS);
+    glColor3f(sin (rotation () / 100.0f), -sin (rotation () / 100.0f), cos (rotation () / 100.0f));
+    glVertex3f(width / 2, height, 0.0f);
+    glColor3f(-sin (rotation () / 100.0f), sin (rotation () / 100.0f), cos (rotation () / 100.0f));
+    glVertex3f(width, height, 0.0f);
+    glColor3f(sin (rotation () / 100.0f), sin (rotation () / 100.0f), sin (rotation () / 100.0f));
+    glVertex3f(width, 0.0f, 0.0f);
+    glColor3f(-sin (rotation () / 100.0f), cos (rotation () / 100.0f), cos (rotation () / 100.0f));
+    glVertex3f(width / 2, 0.0f, 0.0f);
+  glEnd();
+}
+
+class BaseContext
+{
+  public:
+
+    BaseContext (Display *);
+    ~BaseContext ();
+
+    void run ();
+
+  protected:
+
+    bool eventHandler ();
+    bool paintDispatch ();
+
+    enum class ModifierApplication
+    {
+      Square,
+      Triangle,
+      Both
+    };
+
+    void nextWindowPosition ();
+    void nextShapeRotation ();
+    void setupContextForSize (unsigned int width,
+                              unsigned int height);
+    void drawShape (const Shape::Ptr &) {};
+
+  private:
+
+    static gboolean onNewEvents (GIOChannel   *channel,
+                                 GIOCondition condition,
+                                 gpointer     data);
+
+    static gboolean onPaintTimeout (gpointer data);
+
+    static void onWindowThreadCreation (nux::NThread *thread, void *d);
+
+    Display                                   *mDisplay;
+    Window                                    mWindow;
+    Colormap                                  mColormap;
+    nux::WindowThread                         *mWindowThread;
+    nux::View                                 *mRootView;
+    ScreenEffectFramebufferObject::Ptr mFbo;
+    GLXWindow                                 mGlxWindow;
+    GLXContext                                mContext;
+    ModifierApplication                       mRotating;
+    ModifierApplication                       mBlur;
+    unsigned int                              mWidth;
+    unsigned int                              mHeight;
+    bool                                      mNuxReady;
+    Shape::Ptr                                mTriangle;
+    Shape::Ptr                                mSquare;
+};
+
+BaseContext::BaseContext (Display *display) :
+  mDisplay (display),
+  mWindowThread (NULL),
+  mRotating (ModifierApplication::Both),
+  mBlur (ModifierApplication::Both),
+  mWidth (640),
+  mHeight (480),
+  mNuxReady (false),
+  mTriangle  (new Triangle ()),
+  mSquare (new Square ())
+{
+  int            numFBConfig = 0;  
+  GLXFBConfig    *fbConfigs = (*GLFuncs::glXChooseFBConfigP) (mDisplay,
+                                                              DefaultScreen (mDisplay),
+                                                              attributes,
+                                                              &numFBConfig);
+  XVisualInfo    *visinfo = (*GLFuncs::glXGetVisualFromFBConfigP) (mDisplay,
+                                                                   fbConfigs[0]);
+
+  mContext = glXCreateContext (mDisplay, visinfo, 0, GL_TRUE);
+  mColormap = XCreateColormap (mDisplay,
+                               DefaultRootWindow (mDisplay),
+                               visinfo->visual,
+                               AllocNone);
+
+  XSetWindowAttributes wa;
+
+  wa.colormap = mColormap;
+  wa.border_pixel = 0;
+  wa.event_mask = StructureNotifyMask | KeyPressMask | ExposureMask;
+
+  mWindow = XCreateWindow (mDisplay, DefaultRootWindow (mDisplay),
+                           0, 0, mWidth, mHeight, 0, visinfo->depth, InputOutput,
+                           visinfo->visual, CWColormap | CWEventMask | CWBorderPixel,
+                           &wa);
+
+  mGlxWindow = (*GLFuncs::glXCreateWindowP) (mDisplay, fbConfigs[0], mWindow, NULL);
+
+  XStoreName (mDisplay, mWindow, "F1: Toggle Effect, F2: Rotation, F3: Effect");
+  XMapWindow (mDisplay, mWindow);
+
+  bool ready = false;
+
+  do
+  {
+    XEvent ev;
+    XNextEvent (mDisplay, &ev);
+    switch (ev.type)
+    {
+      case MapNotify:
+      case ConfigureNotify:
+      case Expose:
+        ready = true;
+        break;
+      default:
+        break;
+    }
+
+  } while (!ready);
+
+  (*GLFuncs::glXMakeContextCurrentP) (mDisplay, mGlxWindow, mGlxWindow, mContext);
+
+  setupContextForSize (mWidth, mHeight);
+}
+
+void
+BaseContext::run ()
+{
+  GIOChannel        *channel;
+  mWindowThread = nux::CreateFromForeignWindow (mWindow,
+                                                mContext,
+                                                &BaseContext::onWindowThreadCreation,
+                                                (void *) this);
+
+  mWindowThread->Run(NULL);
+
+  while (!mNuxReady);
+  g_timeout_add (128, &BaseContext::onPaintTimeout, (gpointer) this);
+
+  channel = g_io_channel_unix_new (ConnectionNumber (mDisplay));
+
+  g_io_add_watch (channel, (GIOCondition) (G_IO_IN | G_IO_HUP | G_IO_ERR),
+                  &BaseContext::onNewEvents, (gpointer) this);
+  gtk_main ();
+}
+
+BaseContext::~BaseContext ()
+{
+  delete mWindowThread;
+
+  (*GLFuncs::glXMakeContextCurrentP) (mDisplay, None, None, mContext);
+  glXDestroyContext (mDisplay, mContext);
+  (*GLFuncs::glXDestroyWindowP) (mDisplay, mGlxWindow);
+
+  XFreeColormap (mDisplay, mColormap);
+  XDestroyWindow (mDisplay, mWindow);
+}
+
+void
+BaseContext::setupContextForSize (unsigned int width,
+                                  unsigned int height)
+{
+  mWidth = width;
+  mHeight = height;
+
+  glViewport(0, 0, width, height);
+  glDrawBuffer (GL_BACK);
+  glReadBuffer (GL_BACK);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  gluPerspective(60.0f, 1.0f, 0.1f, 100.0f);
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity ();
+  glClearColor (1, 1, 1, 1);
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glXSwapBuffers (mDisplay, mGlxWindow);
+
+  if (mFbo)
+    mFbo.reset (new ScreenEffectFramebufferObject (GLFuncs::glXGetProcAddressP, nux::Geometry (0, 0, mWidth, mHeight)));
+
+  if (mRootView && mNuxReady)
+  {
+    switch (mBlur)
+    {
+      case ModifierApplication::Both:
+        mRootView->SetGeometry (nux::Geometry (0, 0, mWidth / 2, mHeight));
+        break;
+      case ModifierApplication::Triangle:
+        mRootView->SetGeometry (nux::Geometry (mWidth / 2, 0, mWidth / 2, mHeight));
+        break;
+      case ModifierApplication::Square:
+        mRootView->SetGeometry (nux::Geometry (0, 0, mWidth, mHeight));
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+bool
+BaseContext::eventHandler ()
+{
+  XEvent event;
+  XEvent *ev = &event;
+
+  XNextEvent (mDisplay, &event);
+
+  switch (ev->type)
+  {
+    case KeyPress:
+      if (XLookupKeysym (&ev->xkey, 0) == XK_Escape)
+        return false;
+      else if (XLookupKeysym (&ev->xkey, 0) == XK_F1)
+      {
+        if (!mFbo)
+        {
+          BackgroundEffectHelper::blur_type = unity::BLUR_ACTIVE;
+          mFbo.reset (new ScreenEffectFramebufferObject (GLFuncs::glXGetProcAddressP, nux::Geometry (0, 0, mWidth, mHeight)));
+        }
+        else
+        {
+          BackgroundEffectHelper::blur_type = unity::BLUR_NONE;
+          mFbo.reset ();
+        }
+      }
+      else if (XLookupKeysym (&ev->xkey, 0) == XK_F2)
+        nextShapeRotation ();
+      else if (XLookupKeysym (&ev->xkey, 0) == XK_F3)
+        nextWindowPosition ();
+      break;
+    case ConfigureNotify:
+      setupContextForSize (ev->xconfigure.width, ev->xconfigure.height);
+    default:
+      break;
+  }
+
+  return true;
+}
+
+gboolean
+BaseContext::onNewEvents (GIOChannel   *channel,
+                          GIOCondition condition,
+                          gpointer     data)
+{
+  BaseContext *self = static_cast <BaseContext *> (data);
+
+  if (condition & G_IO_IN)
+  {
+    if (self->eventHandler ())
+      return TRUE;
+    else
+      return FALSE;
+  }
+
+  return TRUE;
+}
+
+gboolean
+BaseContext::onPaintTimeout (gpointer data)
+{
+  BaseContext *self = static_cast <BaseContext *> (data);
+
+  if (self->paintDispatch ())
+    return TRUE;
+
+  return FALSE;
+}
+
+void
+BaseContext::nextShapeRotation ()
+{
+  switch (mRotating)
+  {
+    case ModifierApplication::Both:
+      mRotating = ModifierApplication::Triangle;
+      break;
+    case ModifierApplication::Triangle:
+      mRotating = ModifierApplication::Square;
+      break;
+    case ModifierApplication::Square:
+      mRotating = ModifierApplication::Both;
+      break;
+    default:
+      break;
+  }
+}
+
+void
+BaseContext::nextWindowPosition ()
+{
+  switch (mBlur)
+  {
+    case ModifierApplication::Both:
+      mBlur = ModifierApplication::Triangle;
+      mRootView->SetGeometry (nux::Geometry (0, 0, mWidth / 2, mHeight));
+      break;
+    case ModifierApplication::Triangle:
+      mBlur = ModifierApplication::Square;
+      mRootView->SetGeometry (nux::Geometry (mWidth / 2, 0, mWidth / 2, mHeight));
+      break;
+    case ModifierApplication::Square:
+      mBlur = ModifierApplication::Both;
+      mRootView->SetGeometry (nux::Geometry (0, 0, mWidth, mHeight));
+      break;
+    default:
+      break;
+  }
+}
+
+EffectView::EffectView (NUX_FILE_LINE_DECL)
+  : View (NUX_FILE_LINE_PARAM)
+{
+  bg_effect_helper_.owner = this;
+}
+
+EffectView::~EffectView ()
+{
+}
+
+void EffectView::DrawContent (nux::GraphicsEngine &GfxContext, bool force_draw)
+{
+  nux::Geometry base = GetGeometry();
+  GfxContext.PushClippingRectangle(base);
+  nux::Geometry blur_geo (base.x, base.y, base.width, base.height);
+
+  if (BackgroundEffectHelper::blur_type == unity::BLUR_ACTIVE)
+  {
+    bg_effect_helper_.enabled = true;
+
+    auto blur_texture = bg_effect_helper_.GetBlurRegion(blur_geo);
+
+    if (blur_texture.IsValid ())
+    {
+      nux::TexCoordXForm texxform_blur_bg;
+      texxform_blur_bg.flip_v_coord = true;
+      texxform_blur_bg.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+      texxform_blur_bg.uoffset = ((float) base.x) / (base.width);
+      texxform_blur_bg.voffset = ((float) base.y) / (base.height);
+
+      nux::ROPConfig rop;
+      rop.Blend = false;
+      rop.SrcBlend = GL_ONE;
+      rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+      gPainter.PushDrawTextureLayer(GfxContext, base,
+                                    blur_texture,
+                                    texxform_blur_bg,
+                                    nux::color::White,
+                                    true,
+                                    rop);
+    }
+  }
+  else
+    bg_effect_helper_.enabled = false;
+  GfxContext.PopClippingRectangle();
+}
+
+bool
+BaseContext::paintDispatch ()
+{
+  if (mFbo)
+  {
+    switch (mRotating)
+    {
+      case ModifierApplication::Both:
+        BackgroundEffectHelper::ProcessDamage (nux::Geometry (0, 0, mWidth, mHeight));
+        break;
+      case ModifierApplication::Triangle:
+        BackgroundEffectHelper::ProcessDamage (nux::Geometry (0, 0, mWidth / 2, mHeight));
+        break;
+      case ModifierApplication::Square:
+        BackgroundEffectHelper::ProcessDamage (nux::Geometry (mWidth / 2, 0, mWidth / 2, mHeight));
+        break;
+    }
+
+    mFbo->bind (nux::Geometry (0, 0, mWidth, mHeight));
+
+    if (!mFbo->status ())
+    {
+      LOG_INFO (logger) << "FBO not ok!";
+    }
+  }
+
+  glClearColor (1, 1, 1, 1);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glPushMatrix ();
+  glLoadIdentity();
+  glTranslatef(-0.5f, -0.5f, -0.866025404f);
+  glScalef (1.0f / mWidth, 1.0f / mHeight, 0.0f);
+  glTranslatef(mWidth * 0.25, 0, 0);
+  glRotatef(mTriangle->rotation (), 0.0f, 1.0f, 0.0f);
+  glTranslatef(-(mWidth * 0.25), 0, 0);
+
+  mTriangle->draw (mWidth, mHeight);
+
+  glLoadIdentity();
+  glTranslatef(-0.5f, -0.5f, -0.866025404f);
+  glScalef (1.0f / mWidth, 1.0f / mHeight, 0.0f);
+  glTranslatef(mWidth * 0.75, 0, 0);
+  glRotatef(mSquare->rotation (), 0.0f, 1.0f, 0.0f);
+  glTranslatef(-(mWidth * 0.75), 0, 0);
+
+  mSquare->draw (mWidth, mHeight);
+
+  glColor4f (1.0f, 1.0f, 1.0f, 5.0f);
+  glPopMatrix ();
+
+  if (mFbo)
+    mFbo->unbind ();
+
+  if (mFbo && mFbo->status ())
+  {
+    glClearColor (1, 1, 1, 1);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glPushMatrix ();
+    glLoadIdentity();
+    glTranslatef(-0.5f, 0.5f, -0.866025404f);
+    glScalef (1.0f / mWidth, -(1.0f / mHeight), 0.0f);
+    mFbo->paint (nux::Geometry (0, 0, mWidth, mHeight));
+    glPopMatrix ();
+
+    nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture =
+        nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID (mFbo->texture(),
+                                                                          mWidth, mHeight, 1, nux::BITFMT_R8G8B8A8);
+
+    nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
+
+    nux::Geometry geo = nux::Geometry (0, 0, mWidth, mHeight);
+    BackgroundEffectHelper::monitor_rect_ = geo;
+  }
+
+  glMatrixMode(GL_PROJECTION);
+  glPushMatrix();
+
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+  glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT |
+               GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT | GL_SCISSOR_BIT);
+  mRootView->ProcessDraw (mWindowThread->GetGraphicsEngine (), true);
+  glMatrixMode(GL_PROJECTION);
+  glPopMatrix();
+  glMatrixMode(GL_MODELVIEW);
+  glPopMatrix();
+
+  glDrawBuffer(GL_BACK);
+  glReadBuffer(GL_BACK);
+
+  glPopAttrib();
+
+  glXSwapBuffers (mDisplay, mGlxWindow);
+
+  switch (mRotating)
+  {
+    case ModifierApplication::Both:
+      mTriangle->rotate ();
+      mSquare->rotate ();
+      break;
+    case ModifierApplication::Triangle:
+      mTriangle->rotate ();
+      break;
+    case ModifierApplication::Square:
+      mSquare->rotate ();
+      break;
+  }
+
+  return true;
+}
+
+void
+BaseContext::onWindowThreadCreation (nux::NThread *thread, void *data)
+{
+  BaseContext *bc = static_cast <BaseContext *> (data);
+
+  bc->mRootView = new EffectView ();
+  bc->mRootView->SetGeometry (nux::Geometry (0, 0, 640, 480));
+  bc->mNuxReady = true;
+  BackgroundEffectHelper::blur_type = unity::BLUR_ACTIVE;
+}
+
+int main (int argc, char **argv)
+{
+  Display *display = XOpenDisplay (NULL);
+  nux::NuxInitialize (0);
+  GLFuncs::init ();
+	g_type_init ();
+  g_thread_init (NULL);
+  gtk_init(&argc, &argv);
+
+  BaseContext *bc = new BaseContext (display);
+
+  bc->run ();
+
+  delete bc;
+
+  XCloseDisplay (display);
+
+  return 0;
+}
+
+