Merge lp:~smspillaz/unity/unity.less-paint-insanity into lp:unity

[Sam Spilsbury]

Removes the whole scanning of the list thing in getWindowPaintList and the whole "trying to figure out where the window was because we don't actually know" in glDraw by scanning the paint list again and again.

There's a much better way of doing this - just hook glPaint, skip the wrap chain to core (eg every single plugin skipped) and tell core not to do anything with the window.

I have no idea why there is a bunch of logic about whether or not to paint the panel in glDraw (that was moved to glPaint). Someone enlighten me?

[Sam Spilsbury (smspillaz)]

Bump?

I'd like to see this go in, because it should reduce lots of list copying within unity and also lots of unecessary list traversal, which should represent a nice speed boost. In addition, its far simpler in its implementation and far less bug prone.

I'm sure testing is probably an issue. I'll have another quick look at the code and see if I can think of a way to get it under test.

[Daniel van Vugt (vanvugt)]

Works for me. Though there are some indentation/tab mismatches around line 107. Looks like your tabs are not 8 characters wide like they should be?

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

indentation fixed ... will add tests when I have time.

[Daniel van Vugt (vanvugt)]

Manual testing -> Works well.

This branch also appears to solve the problem of my missing panel shadow when running dev builds of Unity. But that's just a bonus.

review: Approve

[Daniel van Vugt (vanvugt)]

Whoops. It turns out this branch is tricking the decor plugin into painting (proper) shadows for the panel and launcher. It looks awesome so I hope we can keep it. But it's probably a mistake.

[Sam Spilsbury (smspillaz)]

> Whoops. It turns out this branch is tricking the decor plugin into painting
> (proper) shadows for the panel and launcher. It looks awesome so I hope we can
> keep it. But it's probably a mistake.

It probably is, thanks for catching that.

review: Needs Fixing

[lp:~smspillaz/unity/unity.less-paint-insanity]

2374. By Sam Spilsbury on 2012-06-12

Merge lp:unity

2375. By Sam Spilsbury on 2012-06-12

Merge lp:~vanvugt/unity/fix-1010348

2376. By Sam Spilsbury on 2012-06-14

Make the code slightly more sane, use some interfaces to demonstrate
what is happening and break dependencies a little

2377. By Sam Spilsbury on 2012-06-14

Ensure that we always paint on top of the topmost nux window

2378. By Sam Spilsbury on 2012-06-14

Also return false if someone tries to paint us with PAINT_WINDOW_NO_CORE_INSTANCE_MASK

2379. By Sam Spilsbury on 2012-06-14

Implement top window detection in terms of paint requestor

2380. By Sam Spilsbury on 2012-06-14

Merge lp:unity

2381. By Sam Spilsbury on 2012-06-14

Move paint requestor enforcement to UnityPaintDispatch

2382. By Sam Spilsbury on 2012-06-14

Move paint mask prohibition into UnityPaintDispatch through strategy

2383. By Sam Spilsbury on 2012-06-14

Ensure that the backing fbo is painted too

2384. By Sam Spilsbury on 2012-06-14

Work correctly with USE_MODERN_COMPIZ_GL too

2385. By Sam Spilsbury on 2012-06-14

Move UnityPaintDispatch to separate file

2386. By Sam Spilsbury on 2012-06-14

Use UnityPaintDispatch by composition

2387. By Sam Spilsbury on 2012-06-14

Rename variable

2388. By Sam Spilsbury on 2012-06-14

UnityPaint* -> ShellPaint*

2389. By Sam Spilsbury on 2012-06-14

mv UnityPaintSchedule -> ShellPaintSchedule

2390. By Sam Spilsbury on 2012-06-14

Initial tests for ShellPaintSchedule

2391. By Sam Spilsbury on 2012-06-14

Basic paint tests

2392. By Sam Spilsbury on 2012-06-14

Basic prohibition test

2393. By Sam Spilsbury on 2012-06-14

Inverse prohibition test case

2394. By Sam Spilsbury on 2012-06-14

Basic top requestor tests

2395. By Sam Spilsbury on 2012-06-14

Test suprvening requestor behaviour

2396. By Sam Spilsbury on 2012-06-14

Tests for RepaintPending value

2397. By Sam Spilsbury on 2012-06-14

Test prohibited paint requestor retreival

2398. By Sam Spilsbury on 2012-06-17

Merge lp:unity

2399. By Sam Spilsbury on 2012-06-19

Merge lp:unity

2400. By Sam Spilsbury on 2012-06-19

Change namespace to unity::compiz

2401. By Sam Spilsbury on 2012-06-19

unsigned int -> enum && move namespace compiz {} to namespace unity::compiz

2402. By Sam Spilsbury on 2012-06-19

Nuke FBOBindingQueryInterface

2403. By Sam Spilsbury on 2012-06-19

Basic documentation, not really a substitute for better code ...

2404. By Sam Spilsbury on 2012-06-25

Merge lp:unity

2405. By Sam Spilsbury on 2012-06-26

Remove unused method and rename methods to make more sense

Unmerged revisions

2405. By Sam Spilsbury on 2012-06-26

Remove unused method and rename methods to make more sense

2404. By Sam Spilsbury on 2012-06-25

Merge lp:unity

2403. By Sam Spilsbury on 2012-06-19

Basic documentation, not really a substitute for better code ...

2402. By Sam Spilsbury on 2012-06-19

Nuke FBOBindingQueryInterface

2401. By Sam Spilsbury on 2012-06-19

unsigned int -> enum && move namespace compiz {} to namespace unity::compiz

2400. By Sam Spilsbury on 2012-06-19

Change namespace to unity::compiz

2399. By Sam Spilsbury on 2012-06-19

Merge lp:unity

2398. By Sam Spilsbury on 2012-06-17

Merge lp:unity

2397. By Sam Spilsbury on 2012-06-14

Test prohibited paint requestor retreival

2396. By Sam Spilsbury on 2012-06-14

Tests for RepaintPending value

=== modified file 'plugins/unityshell/src/ScreenEffectFramebufferObject.cpp'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-05-28 03:19:35 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-06-14 09:04:28 +0000
@@ -76,7 +76,6 @@
   mScreenSize = screenSize;
 }
 
-
 void unity::ScreenEffectFramebufferObject::unbind ()
 {
   if (!mBoundCnt)
@@ -92,6 +91,8 @@
   /* Matches the viewport set we did in ::bind () */
   glPopAttrib ();
 
+  successful_bind_ = true;
+
 }
 
 bool unity::ScreenEffectFramebufferObject::status ()
@@ -106,6 +107,8 @@
    * Because binding has a severe impact on graphics performance and we
    * can't afford to do it every frame. (LP: #861061) (LP: #987304)
    */
+  successful_bind_ = false;
+
   if (!BackgroundEffectHelper::HasDirtyHelpers())
     return;
 
@@ -212,6 +215,11 @@
   mBoundCnt++;
 }
 
+bool
+unity::ScreenEffectFramebufferObject::NewContentsValid ()
+{
+  return successful_bind_;
+}
 
 unity::ScreenEffectFramebufferObject::ScreenEffectFramebufferObject (GLXGetProcAddressProc p, const nux::Geometry &geom)
  : getProcAddressGLX (p)
@@ -220,6 +228,7 @@
  , mGeometry (geom)
  , mBoundCnt (0)
  , mScreenSize (geom)
+ , successful_bind_ (false)
 {
   activeTexture = (GLActiveTextureProc) (*getProcAddressGLX) ((GLubyte *) "glActiveTexture");
   genFramebuffers = (GLGenFramebuffersProc) (*getProcAddressGLX) ((GLubyte *)"glGenFramebuffersEXT");

=== modified file 'plugins/unityshell/src/ScreenEffectFramebufferObject.h'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.h	2012-04-06 10:23:49 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.h	2012-06-14 09:04:28 +0000
@@ -49,6 +49,10 @@
   
   void onScreenSizeChanged (const nux::Geometry &screenSize);
 
+  /* Returns true if the fbo was bound, painted into and unbound
+   * successfully */
+  bool NewContentsValid ();
+
 private:
 
   FuncPtr getProcAddr (const std::string &);
@@ -82,6 +86,8 @@
   unsigned int mBoundCnt;
   
   nux::Geometry mScreenSize;
+
+  bool         successful_bind_;
 };
 } // namespace unity
 

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-06-13 03:54:37 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-06-14 09:04:28 +0000
@@ -110,6 +110,8 @@
   , screen(screen)
   , cScreen(CompositeScreen::get(screen))
   , gScreen(GLScreen::get(screen))
+  , paint_dispatch_ (this,
+                     boost::bind (&UnityScreen::GetProhibitedPaintMasks, this))
   , debugger_(this)
   , enable_shortcut_overlay_(true)
   , gesture_engine_(screen)
@@ -117,8 +119,6 @@
   , _in_paint(false)
   , super_keypressed_(false)
   , newFocusedWindow(nullptr)
-  , doShellRepaint(false)
-  , allowWindowPaint(false)
   , damaged(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
@@ -263,8 +263,8 @@
      if (GL::fbo)
      {
        nux::Geometry geometry (0, 0, screen->width (), screen->height ());
-       uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
-       uScreen->_fbo->onScreenSizeChanged (geometry);
+       uScreen->fbo_ = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+       uScreen->fbo_->onScreenSizeChanged (geometry);
      }
 #endif
 
@@ -734,16 +734,52 @@
   panel_texture_has_changed_ = true;
 }
 
-#ifdef USE_MODERN_COMPIZ_GL
-void UnityScreen::paintDisplay()
+bool
+UnityScreen::WasBound ()
+{
+#ifndef USE_MODERN_COMPIZ_GL
+  return fbo_->NewContentsValid ();
 #else
-void UnityScreen::paintDisplay(const CompRegion& region, const GLMatrix& transform, unsigned int mask)
-#endif
+  return true;
+#endif
+}
+
+unsigned int
+UnityScreen::GetPaintRequestorType ()
+{
+  return ShellPaintRequestorInterface::ScreenPaintRequestor;
+}
+
+bool UnityScreen::PaintBackingFBO (CompOutput *output)
+{
+#ifndef USE_MODERN_COMPIZ_GL
+  fbo_->unbind ();
+  if (fbo_->NewContentsValid ())
+  {
+    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 ();
+
+    return true;
+  }
+#endif
+  return false;
+}
+
+void UnityScreen::PaintDisplay (FBOBindingQueryInterface *fbo_query)
 {
   CompOutput *output = _last_output;
 
+  PaintBackingFBO (output);
+
 #ifndef USE_MODERN_COMPIZ_GL
-  bool was_bound = _fbo->bound ();
+  bool was_bound = fbo_query->WasBound ();
+#else
+  bool was_bound = true;
+#endif
 
   if (nux::GetGraphicsDisplay()->GetGraphicsEngine()->UsingGLSLCodePath())
   {
@@ -779,28 +815,18 @@
     }
   }
 
-  _fbo->unbind ();
-
   /* Draw the bit of the relevant framebuffer for each output */
 
-  if (was_bound)
-  {
-    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 ();
-  }
+  GLuint fbo_texture_name = 0;
+#ifndef USE_MODERN_COMPIZ_GL
+  fbo_texture_name = fbo_->texture();
+#else
+  fbo_texture_name = gScreen->fbo ()->tex ()->name ();
+#endif
 
   nux::ObjectPtr<nux::IOpenGLBaseTexture> device_texture =
-      nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(_fbo->texture(),
+      nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(fbo_texture_name,
                                                                        screen->width (), screen->height(), 1, nux::BITFMT_R8G8B8A8);
-#else
-  nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture =
-    nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(gScreen->fbo ()->tex ()->name (),
-      output->width(), output->height(), 1, nux::BITFMT_R8G8B8A8);
-#endif
 
   nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
 
@@ -823,7 +849,7 @@
 
   for (Window tray_xid : panel_controller_->GetTrayXids())
   {
-    if (tray_xid && !allowWindowPaint)
+    if (tray_xid && (no_paint_allowed_mask_ & ShellPaintRequestorInterface::WindowPaintRequestor))
     {
       CompWindow *tray = screen->findWindow (tray_xid);
 
@@ -901,15 +927,54 @@
     }
   }
 
-  doShellRepaint = false;
   damaged = false;
 }
 
-bool UnityScreen::forcePaintOnTop ()
-{
-    return !allowWindowPaint ||
-      ((switcher_controller_->Visible() || launcher_controller_->IsOverlayOpen())
-       && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
+unsigned int UnityScreen::GetProhibitedPaintMasks ()
+{
+  bool unity_force_overlay = switcher_controller_->Visible() || launcher_controller_->IsOverlayOpen();
+  bool no_screen_grabs = !(screen->grabbed () && !screen->otherGrabExist (NULL));
+  bool fullscreen_windows = !fullscreen_windows_.empty ();
+
+  unsigned int pmask = no_paint_allowed_mask_;
+
+  if (unity_force_overlay &&
+      fullscreen_windows &&
+      no_screen_grabs)
+    pmask |= ShellPaintRequestorInterface::WindowPaintRequestor;
+
+  return pmask;
+}
+
+bool UnityScreen::Paint (ShellPaintRequestorInterface *r,
+                         FBOBindingQueryInterface     *q)
+{
+  return paint_dispatch_.Paint (r, q);
+}
+
+bool UnityScreen::EnforceRequestor (ShellPaintRequestorInterface *r)
+{
+  return paint_dispatch_.EnforceRequestor (r);
+}
+
+void UnityScreen::ClearRequestorEnforcement ()
+{
+  paint_dispatch_.ClearRequestorEnforcement ();
+}
+
+unsigned int UnityScreen::ProhibitedPaintRequestors ()
+{
+  return paint_dispatch_.ProhibitedPaintRequestors ();
+}
+
+void UnityScreen::RequireShellRepaint ()
+{
+  paint_dispatch_.RequireShellRepaint ();
+}
+
+bool UnityScreen::RepaintPending ()
+{
+  return paint_dispatch_.RepaintPending ();
 }
 
 void UnityWindow::paintThumbnail (nux::Geometry const& bounding, float alpha)
@@ -1204,8 +1269,9 @@
 {
   bool ret;
 
-  doShellRepaint = true;
-  allowWindowPaint = true;
+  ClearRequestorEnforcement ();
+  RequireShellRepaint ();
+  no_paint_allowed_mask_ = 0;
   _last_output = output;
   paint_panel_ = false;
 
@@ -1220,16 +1286,13 @@
    *   attempts to bind it will only increment
    *   its bind reference so make sure that
    *   you always unbind as much as you bind */
-  _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
+  fbo_->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
 #endif
 
   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
   ret = gScreen->glPaintOutput(attrib, transform, region, output, mask);
 
-#ifndef USE_MODERN_COMPIZ_GL
-  if (doShellRepaint)
-    paintDisplay(region, transform, mask);
-#endif
+  Paint (this, this);
 
   return ret;
 }
@@ -1241,7 +1304,7 @@
 {
   bool useFbo = false;
 
-  if (doShellRepaint)
+  if (RepaintPending ())
   {
     oldFbo = fbo->bind ();
     useFbo = fbo->checkStatus () && fbo->tex ();
@@ -1250,7 +1313,7 @@
 	::GLFramebufferObject::rebind (oldFbo);
 	return;
     }
-    paintDisplay();
+    Paint (this, this);
     ::GLFramebufferObject::rebind (oldFbo);
   }
 
@@ -1267,7 +1330,7 @@
                                            CompOutput* output,
                                            unsigned int mask)
 {
-  allowWindowPaint = false;
+  no_paint_allowed_mask_ = ShellPaintRequestorInterface::WindowPaintRequestor;
   gScreen->glPaintTransformedOutput(attrib, transform, region, output, mask);
 
 }
@@ -2124,31 +2187,6 @@
   return "Unity";
 }
 
-bool isNuxWindow (CompWindow* value)
-{
-  std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-  auto id = value->id();
-
-  // iterate loop by hand rather than use std::find as this is considerably faster
-  // we care about performance here becuase of the high frequency in which this function is
-  // called (nearly every frame)
-  unsigned int size = xwns.size();
-  for (unsigned int i = 0; i < size; ++i)
-  {
-    if (xwns[i] == id)
-      return true;
-  }
-  return false;
-}
-
-const CompWindowList& UnityScreen::getWindowPaintList()
-{
-  CompWindowList& pl = _withRemovedNuxWindows = cScreen->getWindowPaintList();
-  pl.remove_if(isNuxWindow);
-
-  return pl;
-}
-
 void UnityScreen::RaiseInputWindows()
 {
   std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
@@ -2161,13 +2199,11 @@
   }
 }
 
-/* detect occlusions
- *
- * core passes down the PAINT_WINDOW_OCCLUSION_DETECTION
- * mask when it is doing occlusion detection, so use that
- * order to fill our occlusion buffer which we'll flip
- * to nux later
- */
+/* we want to paint underneath other windows here,
+ * so we need to find if this window is actually
+ * stacked on top of one of the nux input windows
+ * and if so paint nux and stop us from painting
+ * other windows or on top of the whole screen */
 bool UnityWindow::glPaint(const GLWindowPaintAttrib& attrib,
                           const GLMatrix& matrix,
                           const CompRegion& region,
@@ -2187,7 +2223,7 @@
 
   std::vector<Window> const& tray_xids = uScreen->panel_controller_->GetTrayXids();
   if (std::find(tray_xids.begin(), tray_xids.end(), window->id()) != tray_xids.end() &&
-      !uScreen->allowWindowPaint)
+      (uScreen->ProhibitedPaintRequestors () & ShellPaintRequestorInterface::WindowPaintRequestor))
   {
     if (!uScreen->painting_tray_)
     {
@@ -2196,26 +2232,7 @@
     }
   }
 
-  return gWindow->glPaint(wAttrib, matrix, region, mask);
-}
-
-/* handle window painting in an opengl context
- *
- * we want to paint underneath other windows here,
- * so we need to find if this window is actually
- * stacked on top of one of the nux input windows
- * and if so paint nux and stop us from painting
- * other windows or on top of the whole screen */
-bool UnityWindow::glDraw(const GLMatrix& matrix,
-#ifndef USE_MODERN_COMPIZ_GL
-                         GLFragment::Attrib& attrib,
-#else
-                         const GLWindowPaintAttrib& attrib,
-#endif
-                         const CompRegion& region,
-                         unsigned int mask)
-{
-  if (uScreen->doShellRepaint && !uScreen->paint_panel_ && window->type() == CompWindowTypeNormalMask)
+  if (uScreen->RepaintPending () && !uScreen->paint_panel_ && window->type() == CompWindowTypeNormalMask)
   {
     guint32 id = window->id();
     bool maximized = WindowManager::Default()->IsWindowMaximized(id);
@@ -2231,29 +2248,63 @@
     }
   }
 
-  if (uScreen->doShellRepaint && !uScreen->forcePaintOnTop ())
+  if (IsNuxWindow ())
   {
-    std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-    unsigned int size = xwns.size();
-
-    for (CompWindow* w = window; w && uScreen->doShellRepaint; w = w->prev)
-    {
-      auto id = w->id();
-
-      for (unsigned int i = 0; i < size; ++i)
-      {
-        if (xwns[i] == id)
-        {
-#ifdef USE_MODERN_COMPIZ_GL
-          uScreen->paintDisplay();
+    /* Windows are painted in top-to-bottom order
+     * with occlusion detection on, so we can
+     * find out the top most nux window and paint
+     * there */
+    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+    {
+      GLWindowPaintAttrib noAlphaAttrib;
+
+      noAlphaAttrib.opacity = OPAQUE;
+      noAlphaAttrib.brightness = BRIGHT;
+      noAlphaAttrib.saturation = COLOR;
+
+      bool status = gWindow->glPaint (noAlphaAttrib,
+                                      matrix,
+                                      region,
+                                      PAINT_WINDOW_OCCLUSION_DETECTION_MASK);
+
+      if (status)
+        uScreen->EnforceRequestor (this);
+
+      /* We don't want core to take this window
+       * into account when doing occlusion detection
+       * however */
+      return false;
+    }
+    /* Don't care about "fake" paints */
+    else if (mask & PAINT_WINDOW_NO_CORE_INSTANCE_MASK)
+    {
+      return false;
+    }
+    else
+    {
+      uScreen->Paint (this, uScreen);
+
+      /* Don't paint nux windows on the real paint pass */
+      return false;
+    }
+  }
+
+  return gWindow->glPaint(wAttrib, matrix, region, mask);
+}
+
+/* handle window painting in an opengl context
+ */
+bool UnityWindow::glDraw(const GLMatrix& matrix,
+#ifndef USE_MODERN_COMPIZ_GL
+                         GLFragment::Attrib& attrib,
 #else
-          uScreen->paintDisplay(region, matrix, mask);
+                         const GLWindowPaintAttrib& attrib,
 #endif
-          break;
-        }
-      }
-    }
-  }
+                         const CompRegion& region,
+                         unsigned int mask)
+{
+  if (IsNuxWindow ())
+    return false;
 
   if (window->type() == CompWindowTypeDesktopMask)
     uScreen->setPanelShadowMatrix(matrix);
@@ -2272,7 +2323,6 @@
     uScreen->paintPanelShadow(matrix);
   }
 
-
   return ret;
 }
 
@@ -2747,8 +2797,8 @@
 #ifndef USE_MODERN_COMPIZ_GL
   if (GL::fbo)
   {
-    uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
-    uScreen->_fbo->onScreenSizeChanged (geometry);
+    uScreen->fbo_ = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+    uScreen->fbo_->onScreenSizeChanged (geometry);
   }
 #endif
 
@@ -2914,6 +2964,18 @@
   hints_.push_back(std::make_shared<shortcut::Hint>(windows, "", _(" Drag"), _("Resize window."), shortcut::COMPIZ_MOUSE_OPTION, "resize", "initiate_button"));
 }
 
+bool
+UnityWindow::IsNuxWindow ()
+{
+  return is_nux_window_;
+}
+
+unsigned int
+UnityWindow::GetPaintRequestorType ()
+{
+  return ShellPaintRequestorInterface::WindowPaintRequestor;
+}
+
 /* Window init */
 UnityWindow::UnityWindow(CompWindow* window)
   : BaseSwitchWindow (dynamic_cast<BaseSwitchScreen *> (UnityScreen::get (screen)), window)
@@ -2922,10 +2984,16 @@
   , gWindow(GLWindow::get(window))
   , mMinimizeHandler()
   , mShowdesktopHandler(nullptr)
+  , is_nux_window_ (false)
 {
   WindowInterface::setHandler(window);
   GLWindowInterface::setHandler(gWindow);
 
+  std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
+  for (unsigned int i = 0; i < xwns.size(); i++)
+    if (xwns[i] == window->id ())
+        is_nux_window_ = true;
+
   if (UnityScreen::get (screen)->optionGetShowMinimizedWindows () &&
       window->mapNum ())
   {

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-05-30 18:43:17 +0000
+++ plugins/unityshell/src/unityshell.h	2012-06-14 09:04:28 +0000
@@ -52,6 +52,7 @@
 #include "UBusWrapper.h"
 #include "UnityshellPrivate.h"
 #include "UnityShowdesktopHandler.h"
+#include "ShellPaintSchedule.h"
 #ifndef USE_MODERN_COMPIZ_GL
 #include "ScreenEffectFramebufferObject.h"
 #endif
@@ -68,6 +69,10 @@
 
 /* base screen class */
 class UnityScreen :
+  public FBOBindingQueryInterface,
+  public ShellPaintDispatchInterface,
+  public ShellPaintRequestorInterface,
+  public ShellPaintInterface,
   public unity::debug::Introspectable,
   public sigc::trackable,
   public ScreenInterface,
@@ -92,11 +97,8 @@
   void nuxEpilogue();
 
   /* nux draw wrapper */
-#ifdef USE_MODERN_COMPIZ_GL
-  void paintDisplay();
-#else
-  void paintDisplay(const CompRegion& region, const GLMatrix& transform, unsigned int mask);
-#endif
+  bool PaintBackingFBO (CompOutput *output);
+  void PaintDisplay (FBOBindingQueryInterface *);
   void paintPanelShadow(const GLMatrix& matrix);
   void setPanelShadowMatrix(const GLMatrix& matrix);
 
@@ -132,9 +134,6 @@
                                 CompOutput*,
                                 unsigned int);
 
-  /* Pop our InputOutput windows from the paint list */
-  const CompWindowList& getWindowPaintList();
-
   /* handle X11 events */
   void handleEvent(XEvent*);
 
@@ -188,8 +187,6 @@
   void NeedsRelayout();
   void ScheduleRelayout(guint timeout);
 
-  bool forcePaintOnTop ();
-
 protected:
   std::string GetName() const;
   void AddProperties(GVariantBuilder* builder);
@@ -231,6 +228,20 @@
 
   void OnPanelStyleChanged();
 
+  bool WasBound ();
+  unsigned int GetPaintRequestorType ();
+  unsigned int GetProhibitedPaintMasks ();
+
+  bool Paint (ShellPaintRequestorInterface *,
+              FBOBindingQueryInterface     *);
+  bool EnforceRequestor (ShellPaintRequestorInterface *);
+  void ClearRequestorEnforcement ();
+  unsigned int ProhibitedPaintRequestors ();
+  void RequireShellRepaint ();
+  bool RepaintPending ();
+
+  ShellPaintDispatch paint_dispatch_;
+
   Settings dash_settings_;
   dash::Style    dash_style_;
   panel::Style   panel_style_;
@@ -270,12 +281,9 @@
   GLTexture::List _shadow_texture;
 
   /* handle paint order */
-  bool    doShellRepaint;
-  bool    allowWindowPaint;
   bool    damaged;
   bool    _key_nav_mode_requested;
   CompOutput* _last_output;
-  CompWindowList _withRemovedNuxWindows;
 
   nux::Property<nux::Geometry> primary_monitor_;
 
@@ -284,7 +292,7 @@
 #ifdef USE_MODERN_COMPIZ_GL
   ::GLFramebufferObject *oldFbo;
 #else
-  ScreenEffectFramebufferObject::Ptr _fbo;
+  ScreenEffectFramebufferObject::Ptr fbo_;
   GLuint                             _active_fbo;
 #endif
 
@@ -311,15 +319,27 @@
 
   UBusManager ubus_manager_;
   glib::SourceManager sources_;
+  unsigned int no_paint_allowed_mask_;
 
   friend class UnityWindow;
 };
 
+class NuxBridgeWindowInterface
+{
+public:
+
+  virtual ~NuxBridgeWindowInterface () {};
+
+  virtual bool IsNuxWindow () = 0;
+};
+
 class UnityWindow :
   public WindowInterface,
   public GLWindowInterface,
   public ShowdesktopHandlerWindowInterface,
   public compiz::WindowInputRemoverLockAcquireInterface,
+  public NuxBridgeWindowInterface,
+  public ShellPaintRequestorInterface,
   public BaseSwitchWindow,
   public PluginClassHandler <UnityWindow, CompWindow>
 {
@@ -417,7 +437,12 @@
 
   compiz::WindowInputRemoverLock::Ptr GetInputRemover ();
 
+  bool IsNuxWindow ();
+  unsigned int GetPaintRequestorType ();
+
   compiz::WindowInputRemoverLock::Weak input_remover_;
+
+  bool is_nux_window_;
   glib::Source::UniquePtr focus_desktop_timeout_;
 };
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-06-12 08:23:23 +0000
+++ tests/CMakeLists.txt	2012-06-14 09:04:28 +0000
@@ -150,6 +150,7 @@
                  test_unityshell_private.cpp
                  test_showdesktop_handler.cpp
                  test_hud_private.cpp
+                 test_shell_paint_schedule.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/AbstractLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Animator.cpp
                  ${UNITY_SRC}/DebugDBusInterface.cpp
@@ -162,6 +163,7 @@
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStorePrivate.cpp
                  ${CMAKE_SOURCE_DIR}/shortcuts/ShortcutModel.cpp
                  ${CMAKE_SOURCE_DIR}/shortcuts/ShortcutHintPrivate.cpp
+		 ${CMAKE_SOURCE_DIR}/unity-shared/ShellPaintSchedule.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Introspectable.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/TextureCache.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Timer.cpp

=== added file 'tests/test_shell_paint_schedule.cpp'
--- tests/test_shell_paint_schedule.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_shell_paint_schedule.cpp	2012-06-14 09:04:28 +0000
@@ -0,0 +1,284 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY 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
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ *
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+using ::testing::StrictMock;
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Return;
+
+#include "ShellPaintSchedule.h"
+
+using namespace unity;
+
+class MockShellPaintRequestor :
+  public ShellPaintRequestorInterface
+{
+public:
+
+  MOCK_METHOD0 (GetPaintRequestorType, unsigned int ());
+
+};
+
+class MockFBOBindingQuery :
+  public FBOBindingQueryInterface
+{
+public:
+
+  MOCK_METHOD0 (WasBound, bool ());
+};
+
+class MockShellPaint :
+  public ShellPaintInterface
+{
+public:
+
+  MOCK_METHOD1 (PaintDisplay, void (FBOBindingQueryInterface *));
+};
+
+class MockShellPaintDispatch
+{
+public:
+
+  MOCK_METHOD2 (Paint, bool (ShellPaintRequestorInterface *, FBOBindingQueryInterface *));
+  MOCK_METHOD1 (EnforceRequestor, void (ShellPaintRequestorInterface *));
+  MOCK_METHOD0 (ClearRequestorEnforcement, void ());
+  MOCK_METHOD0 (ProhibitedPaintRequestors, unsigned int ());
+  MOCK_METHOD0 (RequireShellRepaint, void ());
+  MOCK_METHOD0 (RepaintPending, bool ());
+};
+
+class TestShellPaintSchedule :
+  public ::testing::Test
+{
+};
+
+TEST(TestShellPaintSchedule, NoPaintWhereNotRequired)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return 0; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.Paint (&r, &q);
+}
+
+TEST(TestShellPaintSchedule, PaintWhereRequired)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return 0; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ());
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r, &q);
+}
+
+TEST(TestShellPaintSchedule, NoPaintTwice)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return 0; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ());
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r, &q);
+  dispatch.Paint (&r, &q);
+}
+
+TEST(TestShellPaintSchedule, NoWindowPaintButScreenPaint)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return ShellPaintRequestorInterface::WindowPaintRequestor; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+
+  dispatch.Paint (&r, &q);
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::ScreenPaintRequestor));
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r, &q);
+}
+
+TEST(TestShellPaintSchedule, NoScreenPaintButWindowPaint)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return ShellPaintRequestorInterface::ScreenPaintRequestor; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::ScreenPaintRequestor));
+
+  dispatch.Paint (&r, &q);
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r, &q);
+}
+
+TEST(TestShellPaintSchedule, TopRequestorOnlyPaints)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r_w1, r_w2;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return 0; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  dispatch.ClearRequestorEnforcement ();
+  dispatch.EnforceRequestor (&r_w2);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (r_w1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+
+  dispatch.Paint (&r_w1, &q);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r_w2, &q);
+}
+
+TEST(TestShellPaintSchedule, SuperveningRequestorOfOtherTypePaints)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r_w1, r_w2, r_s1;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return 0; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  dispatch.ClearRequestorEnforcement ();
+  dispatch.EnforceRequestor (&r_w2);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (r_w1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+
+  dispatch.Paint (&r_w1, &q);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (r_s1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::ScreenPaintRequestor));
+
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r_s1, &q);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+
+  dispatch.Paint (&r_w2, &q);
+}
+
+TEST(TestShellPaintSchedule, DoubleEnforcementHasNoEffect)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r_w1, r_w2;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return 0; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  dispatch.ClearRequestorEnforcement ();
+  dispatch.EnforceRequestor (&r_w2);
+  dispatch.EnforceRequestor (&r_w1);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (r_w1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+
+  dispatch.Paint (&r_w1, &q);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r_w2, &q);
+}
+
+TEST(TestShellPaintSchedule, GetPendingRepaint)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  MockFBOBindingQuery q;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> unsigned int { return 0; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  EXPECT_FALSE (dispatch.RepaintPending ());
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_TRUE (dispatch.RepaintPending ());
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::WindowPaintRequestor));
+  EXPECT_CALL (p, PaintDisplay (&q));
+
+  dispatch.Paint (&r, &q);
+
+  EXPECT_FALSE (dispatch.RepaintPending ());
+}
+
+TEST(TestShellPaintSchedule, GetProhibitedPaintMasks)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  MockFBOBindingQuery q;
+  unsigned int prohibited_paint_mask = 0;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([&]() -> unsigned int { return prohibited_paint_mask; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  EXPECT_EQ (prohibited_paint_mask, dispatch.ProhibitedPaintRequestors ());
+  prohibited_paint_mask = ShellPaintRequestorInterface::WindowPaintRequestor;
+  EXPECT_EQ (prohibited_paint_mask, dispatch.ProhibitedPaintRequestors ());
+  prohibited_paint_mask = ShellPaintRequestorInterface::ScreenPaintRequestor;
+  EXPECT_EQ (prohibited_paint_mask, dispatch.ProhibitedPaintRequestors ());
+}

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2012-05-22 10:15:47 +0000
+++ unity-shared/CMakeLists.txt	2012-06-14 09:04:28 +0000
@@ -47,6 +47,7 @@
      PanelStyle.cpp
      SearchBar.cpp
      SearchBarSpinner.cpp
+     ShellPaintSchedule.cpp
      StaticCairoText.cpp
      TextureCache.cpp
      Timer.cpp

=== added file 'unity-shared/ShellPaintSchedule.cpp'
--- unity-shared/ShellPaintSchedule.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/ShellPaintSchedule.cpp	2012-06-14 09:04:28 +0000
@@ -0,0 +1,91 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include "ShellPaintSchedule.h"
+
+namespace unity
+{
+
+ShellPaintDispatch::ShellPaintDispatch (ShellPaintInterface *paint_interface,
+                                        const GetProhibitedPaintMasksFunc &prohibited_func) :
+  shell_repaint_required_ (false),
+  top_requestor_ (nullptr),
+  prohibited_paint_masks_func_ (prohibited_func),
+  paint_interface_ (paint_interface)
+{
+}
+
+bool
+ShellPaintDispatch::Paint (ShellPaintRequestorInterface *requestor,
+                           FBOBindingQueryInterface     *fbo_query)
+{
+  if (!shell_repaint_required_)
+    return false;
+
+  if (prohibited_paint_masks_func_ () & requestor->GetPaintRequestorType ())
+    return false;
+
+  if (top_requestor_)
+    if ((top_requestor_->GetPaintRequestorType () &
+        requestor->GetPaintRequestorType ()) && top_requestor_ != requestor)
+      return false;
+
+  paint_interface_->PaintDisplay (fbo_query);
+
+  shell_repaint_required_ = false;
+
+  return true;
+}
+
+bool
+ShellPaintDispatch::EnforceRequestor (ShellPaintRequestorInterface *requestor)
+{
+  if (top_requestor_)
+    return false;
+
+  top_requestor_ = requestor;
+
+  return true;
+}
+
+void
+ShellPaintDispatch::ClearRequestorEnforcement ()
+{
+  top_requestor_ = nullptr;
+}
+
+unsigned int
+ShellPaintDispatch::ProhibitedPaintRequestors ()
+{
+  return prohibited_paint_masks_func_ ();
+}
+
+void
+ShellPaintDispatch::RequireShellRepaint ()
+{
+  shell_repaint_required_ = true;
+}
+
+bool
+ShellPaintDispatch::RepaintPending ()
+{
+  return shell_repaint_required_;
+}
+
+}

=== added file 'unity-shared/ShellPaintSchedule.h'
--- unity-shared/ShellPaintSchedule.h	1970-01-01 00:00:00 +0000
+++ unity-shared/ShellPaintSchedule.h	2012-06-14 09:04:28 +0000
@@ -0,0 +1,104 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#ifndef UNITY_PAINT_SCHEDULE_H
+#define UNITY_PAINT_SCHEDULE_H
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+namespace unity
+{
+
+class ShellPaintRequestorInterface
+{
+public:
+
+
+  static const unsigned int WindowPaintRequestor = (1 << 0);
+  static const unsigned int ScreenPaintRequestor = (1 << 1);
+
+  virtual ~ShellPaintRequestorInterface () {}
+
+  virtual unsigned int GetPaintRequestorType () = 0;
+};
+
+class FBOBindingQueryInterface
+{
+public:
+
+  virtual ~FBOBindingQueryInterface () {}
+  virtual bool WasBound () = 0;
+};
+
+class ShellPaintInterface
+{
+public:
+
+  virtual ~ShellPaintInterface () {};
+
+  virtual void PaintDisplay (FBOBindingQueryInterface     *) = 0;
+};
+
+class ShellPaintDispatchInterface
+{
+public:
+
+  virtual ~ShellPaintDispatchInterface () {}
+
+  virtual bool Paint (ShellPaintRequestorInterface *,
+                      FBOBindingQueryInterface     *) = 0;
+  virtual bool EnforceRequestor (ShellPaintRequestorInterface *) = 0;
+  virtual void ClearRequestorEnforcement () = 0;
+  virtual unsigned int ProhibitedPaintRequestors () = 0;
+  virtual void RequireShellRepaint () = 0;
+  virtual bool RepaintPending () = 0;
+
+};
+
+class ShellPaintDispatch :
+  public ShellPaintDispatchInterface
+{
+public:
+
+  typedef boost::function <unsigned int ()> GetProhibitedPaintMasksFunc;
+
+  ShellPaintDispatch (ShellPaintInterface * paint_interface,
+                      const GetProhibitedPaintMasksFunc &func);
+
+  bool Paint (ShellPaintRequestorInterface *,
+              FBOBindingQueryInterface     *);
+  bool EnforceRequestor (ShellPaintRequestorInterface *);
+  void ClearRequestorEnforcement ();
+  unsigned int ProhibitedPaintRequestors ();
+  void RequireShellRepaint ();
+  bool RepaintPending ();
+
+
+protected:
+
+  bool shell_repaint_required_;
+  ShellPaintRequestorInterface *top_requestor_;
+  GetProhibitedPaintMasksFunc prohibited_paint_masks_func_;
+  ShellPaintInterface *paint_interface_;
+};
+
+}
+
+#endif