Merge lp:~canonical-dx-team/unity/uninty.cleanup-do-a-beryl-roll into lp:unity

[Sam Spilsbury]

Cleanup of the unity plugin, removed unused functions, ensure that we load last, remove useless comments etc

Cleanup of the unity plugin, removed unused functions, ensure that we load last, remove useless comments etc

[Jason Smith (jassmith)]

+1

review: Approve

=== modified file 'src/unity.cpp'
--- src/unity.cpp	2010-11-25 07:10:40 +0000
+++ src/unity.cpp	2010-11-25 16:12:10 +0000
@@ -3,6 +3,7 @@
  *
  * Copyright (c) 2010 Sam Spilsbury <[e-mail]>
  *                    Jason Smith <[e-mail]>
+ * Copyright (c) 2010 Canonical Ltd.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -38,31 +39,15 @@
 
 #include <core/atoms.h>
 
-/* You must also call this. This creates a proper vTable for a plugin name in the 
- * first argument (it's a macro, so you don't need a string). This changes from
- * time to time as the vTable changes, so it is a good way of ensure plugins keep
- * current */
-
+/* Set up vtable symbols */
 COMPIZ_PLUGIN_20090315 (unityshell, UnityPluginVTable);
 
-/* This is the function that is called before the screen is 're-painted'. It is used for animation
- * and such because it gives you a time difference between when the last time the screen was repainted
- * and the current time of the execution of the functions in milliseconds). It's part of the composite
- * plugin's interface
- */
 static UnityScreen *uScreen = 0;
 
 void
-UnityScreen::preparePaint (int ms)
-{
-    /* At the end of every function, you must call BaseClass->functionName (args) in order to pass on
-     * the call chain */
-    cScreen->preparePaint (ms);
-}
-
-void
 UnityScreen::nuxPrologue ()
 {
+    /* reset matrices */
     glPushAttrib (GL_VIEWPORT_BIT | GL_ENABLE_BIT | GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT);
     
     glMatrixMode (GL_PROJECTION);
@@ -110,16 +95,13 @@
     doShellRepaint = false;
 }
 
-/* This is the guts of the paint function. You can transform the way the entire output is painted
- * or you can just draw things on screen with openGL. The unsigned int here is a mask for painting
- * the screen, see opengl/opengl.h on how you can change it */
-
+/* called whenever we need to repaint parts of the screen */
 bool
-UnityScreen::glPaintOutput (const GLScreenPaintAttrib &attrib, // Some basic attribs on how the screen should be painted
-			      const GLMatrix		&transform, // Screen transformation matrix
-			      const CompRegion		&region, // Region of screen being painted
-			      CompOutput 		*output, // Output properties. Use this to the get output width and height for the output being painted
-			      unsigned int		mask /* Some other paint properties, see opengl.h */)
+UnityScreen::glPaintOutput (const GLScreenPaintAttrib   &attrib,
+			    const GLMatrix		&transform,
+			    const CompRegion		&region,
+			    CompOutput 			*output,
+			    unsigned int		mask)
 {
     bool ret;
 
@@ -135,32 +117,21 @@
     return ret;
 }
 
-/* This is called when the output is transformed by a matrix. Basically the same, but core has
- * done a few things for us like clip planes etc */
+/* called whenever a plugin needs to paint the entire scene
+ * transformed */
 
 void
-UnityScreen::glPaintTransformedOutput (const GLScreenPaintAttrib &attrib, // Some basic attribs on how the screen should be painted
-			      		 const GLMatrix		&transform, // Screen transformation matrix
-			      		 const CompRegion	&region, // Region of screen being painted
-			      		 CompOutput 		*output, // Output properties. Use this to the get output width and height for the output being painted
-			      		 unsigned int		mask /* Some other paint properties, see opengl.h */)
+UnityScreen::glPaintTransformedOutput (const GLScreenPaintAttrib &attrib,
+			      	       const GLMatrix		 &transform,
+			      	       const CompRegion		 &region,
+			      	       CompOutput 		 *output,
+			      	       unsigned int		 mask)
 {
     allowWindowPaint = false;
-    /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
     gScreen->glPaintOutput (attrib, transform, region, output, mask);
 }
 
-/* This is called after screen painting is finished. It gives you a chance to do any cleanup and or
- * call another repaint with screen->damageScreen (). It's also part of the composite plugin's
- * interface.
- */
-
-void
-UnityScreen::donePaint ()
-{
-    cScreen->donePaint ();
-}
-
+/* Grab changed nux regions and add damage rects for them */
 void
 UnityScreen::damageNuxRegions ()
 {
@@ -184,10 +155,7 @@
     wt->ClearDrawList ();
 }
 
-/* This is our event handler. It directly hooks into the screen's X Event handler and allows us to handle
- * our raw X Events
- */
-
+/* handle X Events */
 void
 UnityScreen::handleEvent (XEvent *event)
 {
@@ -199,43 +167,56 @@
     }
 }			
 
+
+gboolean
+UnityScreen::initPluginActions (gpointer data)
+{
+    CompPlugin *p;
+
+    p = CompPlugin::find ("expo");
+
+    if (p)
+    {
+	foreach (CompOption &option, p->vTable->getOptions ())
+	{
+	    if (option.name () == "expo_key")
+	    {
+		CompAction *action = &option.value ().action ();
+		PluginAdapter::Default ()->SetExpoAction (action);
+		break;
+	    }
+	}
+    }
+
+    p = CompPlugin::find ("scale");
+
+    if (p)
+    {
+	foreach (CompOption &option, p->vTable->getOptions ())
+	{
+	    if (option.name () == "initiate_all_key")
+	    {
+		CompAction *action = &option.value ().action ();
+		PluginAdapter::Default ()->SetScaleAction (action);
+		break;
+	    }
+	}
+    }
+
+    return FALSE;
+}
+
+/* Set up expo and scale actions on the launcher */
 bool
 UnityScreen::initPluginForScreen (CompPlugin *p)
 {
-    if (g_strcmp0 (p->vTable->name ().c_str (), "expo") == 0)
-    {
-        CompOption::Vector &options = p->vTable->getOptions ();
-        
-        foreach (CompOption& option, options)
-        {
-          if (g_strcmp0 (option.name ().c_str () , "expo_key") == 0)
-          {
-              CompAction *expoAction = &option.value ().action ();
-              
-              PluginAdapter::Default ()->SetExpoAction (expoAction);
-              break;
-          }
-        }
-    }
-    
-    if (g_strcmp0 (p->vTable->name ().c_str (), "scale") == 0)
-    {
-        CompOption::Vector &options = p->vTable->getOptions ();
-        
-        foreach (CompOption& option, options)
-        {
-          if (g_strcmp0 (option.name ().c_str () , "initiate_all_key") == 0)
-          {
-              CompAction *scaleAction = &option.value ().action ();
-              
-              PluginAdapter::Default ()->SetScaleAction (scaleAction);
-              break;
-          }
-        }
+    if (p->vTable->name () == "expo" ||
+	p->vTable->name () == "scale")
+    {
+        initPluginActions ((void *) this);
     }
 
-    screen->initPluginForScreen (p);
-    return true;
+    return screen->initPluginForScreen (p);
 }
 
 void
@@ -246,29 +227,21 @@
 const gchar*
 UnityScreen::GetName ()
 {
-	return "Unity";
-}
-
-/* This gets called whenever the window needs to be repainted. WindowPaintAttrib gives you some
- * attributes like brightness/saturation etc to play around with. GLMatrix is the window's
- * transformation matrix. the unsigned int is the mask, have a look at opengl.h on what you can do
- * with it */
-bool
-UnityWindow::glPaint (const GLWindowPaintAttrib &attrib, // Brightness, Saturation, Opacity etc
-      const GLMatrix &transform, // Transformation Matrix
-      const CompRegion &region, // Repaint region
-      unsigned int mask) // Other flags. See opengl.h
-{
-    bool ret;
-    ret = gWindow->glPaint (attrib, transform, region, mask);
-    return ret;
-}
-
+    return "Unity";
+}
+
+/* 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,
-			     GLFragment::Attrib &attrib,
-			     const CompRegion 	&region,
-			     unsigned int	mask)
+		     GLFragment::Attrib &attrib,
+		     const CompRegion 	&region,
+		     unsigned int	mask)
 {
     if (uScreen->doShellRepaint && uScreen->allowWindowPaint)
     {
@@ -287,98 +260,8 @@
     
     return ret;
 }
-/* This get's called whenever a window's rect is damaged. You can do stuff here or you can adjust the damage
- * rectangle so that the window will update properly. Part of the CompositeWindowInterface.
- */
-
-bool
-UnityWindow::damageRect (bool initial, // initial damage?
-    const CompRect &rect) // The actual rect. Modifyable.
-{
-    bool ret;
-
-    ret = cWindow->damageRect (initial, rect);
-
-    return ret;
-}
-
-/* This is called whenever the window is focussed */
-
-bool
-UnityWindow::focus ()
-{
-    bool ret;
-
-    ret = window->focus ();
-
-    return ret;
-}
-
-/* This is called whenever the window is activated */
-
-void
-UnityWindow::activate ()
-{
-    window->activate ();
-}
-
-/* This is called whenever the window must be placed. You can alter the placement position by altering
- * the CompPoint & */
-
-bool
-UnityWindow::place (CompPoint &point)
-{
-    bool ret;
-
-    ret = window->place (point);
-    return ret;
-}
-
-/* This is called whenever the window is moved. It tells you how far it's been moved and whether that
- * move should be immediate or animated. (Immediate is usually for a sudden move, false for that
- * usually means the user moved the window */
-
-void
-UnityWindow::moveNotify (int dx,
-            int dy,
-            bool immediate)
-{
-    window->moveNotify (dx, dy, immediate);
-}
-
-/* This is called whenever the window is resized. It tells you how much the window has been resized */
-
-void
-UnityWindow::resizeNotify (int dx,
-              int dy,
-              int dwidth,
-              int dheight)
-{
-    window->resizeNotify (dx, dy, dwidth, dheight);
-}
-
-/* This is called when another plugin deems a window to be 'grabbed'. You can't actually 'grab' a
- * window in X, but it is useful in case you need to know when a user has grabbed a window for some reason */
-
-void
-UnityWindow::grabNotify (int x,
-            int y,
-            unsigned int state,
-            unsigned int mask)
-{
-    window->grabNotify (x, y, state, mask);
-}
-
-/* This is called when a window in released from a grab. See above */
-
-void
-UnityWindow::ungrabNotify ()
-{
-    window->ungrabNotify ();
-}
-
-/* This is called when another misc notification arises, such as Map/Unmap etc */
-
+
+/* Called whenever a window is mapped, unmapped, minimized etc */
 void
 UnityWindow::windowNotify (CompWindowNotify n)
 {
@@ -388,7 +271,7 @@
     window->windowNotify (n);
 }
 
-
+/* Configure callback for the launcher window */
 void 
 UnityScreen::launcherWindowConfigureCallback(int WindowWidth, int WindowHeight, nux::Geometry& geo, void *user_data)
 {
@@ -396,13 +279,14 @@
     geo = nux::Geometry(0, 24, geo.width, OurWindowHeight);
 }
 
+/* Configure callback for the panel window */
 void 
 UnityScreen::panelWindowConfigureCallback(int WindowWidth, int WindowHeight, nux::Geometry& geo, void *user_data)
 {
     geo = nux::Geometry(0, 0, WindowWidth, 24);
 }
 
-
+/* Start up nux after OpenGL is initialized */
 void 
 UnityScreen::initUnity(nux::NThread* thread, void* InitData)
 {
@@ -418,6 +302,7 @@
   damageNuxRegions ();
 }
 
+/* Handle option changes and plug that into nux windows */
 void
 UnityScreen::optionChanged (CompOption            *opt,
 			    UnityshellOptions::Options num)
@@ -436,8 +321,8 @@
     }
 }
 
-UnityScreen::UnityScreen (CompScreen *screen) :// The constructor takes a CompScreen *,
-    PluginClassHandler <UnityScreen, CompScreen> (screen), // Initiate PluginClassHandler class template
+UnityScreen::UnityScreen (CompScreen *screen) :
+    PluginClassHandler <UnityScreen, CompScreen> (screen),
     screen (screen),
     cScreen (CompositeScreen::get (screen)),
     gScreen (GLScreen::get (screen)),
@@ -451,10 +336,10 @@
     gtk_init (NULL, NULL);
     
     XSetErrorHandler (old_handler);
-    
-    ScreenInterface::setHandler (screen); // Sets the screen function hook handler
-    CompositeScreenInterface::setHandler (cScreen); // Ditto for cScreen
-    GLScreenInterface::setHandler (gScreen); // Ditto for gScreen
+
+    /* Wrap compiz interfaces */
+    ScreenInterface::setHandler (screen);
+    GLScreenInterface::setHandler (gScreen);
     
     StartupNotifyService::Default ()->SetSnDisplay (screen->snDisplay (), screen->screenNum ());
 
@@ -469,22 +354,21 @@
     wt->Run (NULL);
     uScreen = this;
 
-	debugger = new IntrospectionDBusInterface (this);
+    debugger = new IntrospectionDBusInterface (this);
 	
     PluginAdapter::Initialize (screen);
 
     optionSetLauncherAutohideNotify (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
     optionSetLauncherFloatNotify (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
+
+    g_timeout_add (0, &UnityScreen::initPluginActions, this);
 }
 
-/* This is the destructor. It is called when the class is destroyed. If you allocated any
- * memory or need to do some cleanup, here is where you do it. Note the tilde (~)?
- */
-
 UnityScreen::~UnityScreen ()
 {
 }
 
+/* Can't create windows until after we have initialized everything */
 gboolean UnityScreen::strutHackTimeout (gpointer data)
 {
     UnityScreen *self = (UnityScreen*) data;  
@@ -501,6 +385,7 @@
     return FALSE;
 }
 
+/* Start up the launcher */
 void UnityScreen::initLauncher (nux::NThread* thread, void* InitData)
 {
   UnityScreen *self = (UnityScreen*) InitData;
@@ -551,36 +436,26 @@
   self->panelWindow->InputWindowEnableStruts(true);
   
   g_timeout_add (2000, &UnityScreen::strutHackTimeout, self);
-  
-  /*self->launcher->SetAutohide (true, (nux::View*) self->panelView->HomeButton ());
-  self->launcher->SetFloating (true);*/
 }
 
+/* Window init */
 UnityWindow::UnityWindow (CompWindow *window) :
-    PluginClassHandler <UnityWindow, CompWindow> (window), // Initiate our PrivateHandler class template
-    window (window), 
-    cWindow (CompositeWindow::get (window)),
+    PluginClassHandler <UnityWindow, CompWindow> (window),
+    window (window),
     gWindow (GLWindow::get (window))
 {
-    WindowInterface::setHandler (window); // Sets the window function hook handler
-    CompositeWindowInterface::setHandler (cWindow); // Ditto for cWindow
-    GLWindowInterface::setHandler (gWindow); // Ditto for gWindow
+    WindowInterface::setHandler (window);
+    GLWindowInterface::setHandler (gWindow);
 }
 
 UnityWindow::~UnityWindow ()
 {
 }
 
-/* This is the very first function compiz calls. It kicks off plugin initialization */
-
+/* vtable init */
 bool
 UnityPluginVTable::init ()
 {
-    /* Calls to checkPluginABI check the ABI of a particular plugin to see if it is loaded
-     * and in sync with your current build. If it fails the plugin will not load otherwise
-     * compiz will crash.
-     */
-
     if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
 	 return false;
     if (!CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI))

=== modified file 'src/unity.h'
--- src/unity.h	2010-11-25 07:10:40 +0000
+++ src/unity.h	2010-11-25 16:12:10 +0000
@@ -2,6 +2,7 @@
  * unity.h
  *
  * Copyright (c) 2008 Sam Spilsbury <[e-mail]>
+ * Copyright (c) 2010 Canonical Ltd.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -18,27 +19,11 @@
  * not be able to re-use it if you want to use a different licence.
  */
 
-/* The include path is set to /PREFIX/include/compiz in the Makefile, so you
- * don't need to worry about not being able to find compiz headers */
-
 #include <core/core.h>
-
-/* You need to include this in order to get access to the CompPrivate templates */
-
 #include <core/pluginclasshandler.h>
-
-/* Compositing is no longer built in by-default, so you need to include the interface
- * of the composite plugin.
- */
-
 #include <composite/composite.h>
-
-/* OpenGL support is now no longer built in by-default as well. You have to use the
- * interface of the opengl plugin if you want to do anything with that. */
-
 #include <opengl/opengl.h>
 
-/* This is the options class header created for us automatically on build with BCOP */
 #include "unityshell_options.h"
 
 #include "Introspectable.h"
@@ -49,118 +34,65 @@
 #include <Nux/WindowThread.h>
 #include <sigc++/sigc++.h>
 
-/* This is your base screen class. This class definition can be considered the top most
- * as there is no multi-screen or multi-display support in compiz++, only one compiz
- * instance per screen.
- */
-
+/* base screen class */
 class UnityScreen : 
-	public Introspectable,
+    public Introspectable,
     public sigc::trackable,
-    /* You should inherit the ScreenInterface class if you want to dynamically hook
-     * screen-level core functions. */
     public ScreenInterface,
-    /* Same goes for screen functions in the composite plugin */
     public CompositeScreenInterface,
-    /* And opengl plugin */
     public GLScreenInterface,
-    /* This sets up a privates handler, where you can access an instance of your class for
-     * every CompScreen object (same goes for UnityWindow and CompWindow). It adds the 
-     * member function ::get, which will allow you get an instance of this class from a
-     * CompScreen * object. Oh, and the memory management is done for you now ^_^
-     */
     public PluginClassHandler <UnityScreen, CompScreen>,
-    /* And finally, because we are using BCOP to generate our options, it creates a class
-     * with a bunch of getters and setters that are added to out class when we inherit it. Yay.
-     */
     public UnityshellOptions
 {
 
     public:
 
-	/* Lets get into buisness. This is the constructor, it replaces the initScreen, initEtc
-         * things that used to be in compiz and is called automatically when an instance of this
-         * class is created. Notice how it is the same name as the class name. It has to be that way.
-         */
-
+	/* Init */
 	UnityScreen (CompScreen *s);
 
-	/* This is the destructor. It is called when the class is destroyed. If you allocated any
-	 * memory or need to do some cleanup, here is where you do it. Note the tilde (~)?
-	 */
-
+	/* Cleanup */
 	~UnityScreen ();
 
-	/* We store CompositeScreen, GLScreen, and CompScreen to avoid unecessary calls to ::get */
+	/* We store these  to avoid unecessary calls to ::get */
 	CompScreen      *screen;
 	CompositeScreen *cScreen;
         GLScreen        *gScreen;
 
-	/* Now. Because we imported ScreenInterface and CompositeScreenInterface, we get all the
-	 * core functions in there for free. Here's the twist. Those functions are stored as 'virtual',
-	 * so they can be overridden. That is what we do here. So instead of a core function being called,
-	 * our own is
-	 */
-
-	/* This is the function that is called before the screen is 're-painted'. It is used for animation
-	 * and such because it gives you a time difference between when the last time the screen was repainted
-	 * and the current time of the execution of the functions in milliseconds). It's part of the composite
-	 * plugin's interface
-	 */
-
-	void
-	preparePaint (int);
-
-	/* This is the guts of the paint function. You can transform the way the entire output is painted
-	 * or you can just draw things on screen with openGL. The unsigned int here is a mask for painting
-	 * the screen, see opengl/opengl.h on how you can change it */
-	 
+	/* prepares nux for drawing */	 
 	void
 	nuxPrologue ();
-	 
+
+	/* pops nux draw stack */
 	void
 	nuxEpilogue ();
-	
-	void
-	paintDisplay (const CompRegion 	&region);
-
-	bool
-	glPaintOutput (const GLScreenPaintAttrib &,
-		       const GLMatrix &, const CompRegion &,
-		       CompOutput *, unsigned int);
-
-	/* This is called when the output is transformed by a matrix. Basically the same, but core has
-	 * done a few things for us like clip planes etc */
-
-	void
-	glPaintTransformedOutput (const GLScreenPaintAttrib &,
-		       		  const GLMatrix &, const CompRegion &,
-		       		  CompOutput *, unsigned int);
-
-
-	/* This is called after screen painting is finished. It gives you a chance to do any cleanup and or
-	 * call another repaint with screen->damageScreen (). It's also part of the composite plugin's
-	 * interface.
-	 */
-
-	void
-	donePaint ();
-
-	/* This is our event handler. It directly hooks into the screen's X Event handler and allows us to handle
-	 * our raw X Events
-	 */
-
-	void
-	handleEvent (XEvent *);
-
+
+	/* nux draw wrapper */
+	void paintDisplay (const CompRegion 	&region);
+
+	/* paint on top of all windows if we could not find a window
+	 * to paint underneath */
+	bool glPaintOutput (const GLScreenPaintAttrib &,
+			    const GLMatrix &,
+			    const CompRegion &,
+		       	    CompOutput *,
+			    unsigned int);
+
+	/* paint in the special case that the output is transformed */
+	void glPaintTransformedOutput (const GLScreenPaintAttrib &,
+		       		       const GLMatrix &,
+				       const CompRegion &,
+		       		       CompOutput *,
+				       unsigned int);
+
+	/* handle X11 events */
+	void handleEvent (XEvent *);
+
+	/* handle option changes and change settings inside of the
+	 * panel and dock views */
 	void optionChanged (CompOption *, Options num);
 
-	
-	bool
-	initPluginForScreen (CompPlugin *p);
-
-	bool			doShellRepaint;
-	bool      allowWindowPaint;
+	/* init plugin actions for screen */
+	bool initPluginForScreen (CompPlugin *p);
 
     protected:
 
@@ -169,6 +101,9 @@
 	void AddProperties (GVariantBuilder *builder);
 	
     private:
+
+	static gboolean
+	initPluginActions (gpointer data);
     
 	static void
 	initLauncher (nux::NThread* thread, void* InitData);
@@ -200,13 +135,15 @@
 	nux::Geometry           lastTooltipArea;
 	IntrospectionDBusInterface 		*debugger;
 
-  friend class UnityWindow;
+	/* handle paint order */
+	bool	  doShellRepaint;
+	bool      allowWindowPaint;
+
+	friend class UnityWindow;
 };
 
 class UnityWindow :
-    /* Same for Unity Screen, inherit interfaces, private handlers, options */
     public WindowInterface,
-    public CompositeWindowInterface,
     public GLWindowInterface,
     public PluginClassHandler <UnityWindow, CompWindow>
 {
@@ -214,77 +151,23 @@
     public:
 
         /* Constructors, destructors etc */
-
 	UnityWindow (CompWindow *);
 	~UnityWindow ();
 
-	/* We store CompositeWindow, GLWindow, and CompWindow to avoid unecessary calls to ::get */
 	CompWindow      *window;
-	CompositeWindow *cWindow;
-        GLWindow        *gWindow;
-
-	/* This gets called whenever the window needs to be repainted. WindowPaintAttrib gives you some
-	 * attributes like brightness/saturation etc to play around with. GLMatrix is the window's
-	 * transformation matrix. the unsigned int is the mask, have a look at opengl.h on what you can do
-	 * with it */
-
-	bool
-	glPaint (const GLWindowPaintAttrib &, const GLMatrix &,
-		 const CompRegion &, unsigned int);
+	GLWindow	*gWindow;
 	
+	/* basic window draw function */
 	bool 
 	glDraw (const GLMatrix 	&matrix,
 	        GLFragment::Attrib &attrib,
 	        const CompRegion 	&region,
 	        unsigned int	mask);
 
-	/* This get's called whenever a window's rect is damaged. You can do stuff here or you can adjust the damage
-	 * rectangle so that the window will update properly. Part of the CompositeWindowInterface.
-	 */
-
-	bool
-	damageRect (bool, const CompRect &);
-
-	/* This is called whenever the window is focussed */
-	bool
-	focus ();
-
-	/* This is called whenever the window is activated */
-	void
-	activate ();
-
-	/* This is called whenever the window must be placed. You can alter the placement position by altering
-	 * the CompPoint & */
-	bool
-	place (CompPoint &);
-
-	/* This is called whenever the window is moved. It tells you how far it's been moved and whether that
-	 * move should be immediate or animated. (Immediate is usually for a sudden move, false for that
-	 * usually means the user moved the window */
-	void
-	moveNotify (int, int, bool);
-
-	/* This is called whenever the window is resized. It tells you how much the window has been resized */
-	void
-	resizeNotify (int, int, int, int);
-
-	/* This is called when another plugin deems a window to be 'grabbed'. You can't actually 'grab' a
-	 * window in X, but it is useful in case you need to know when a user has grabbed a window for some reason */
-	void
-	grabNotify (int, int, unsigned int, unsigned int);
-
-	/* This is called when a window in released from a grab. See above */
-	void
-	ungrabNotify ();
-
-	/* This is called when another misc notification arises, such as Map/Unmap etc */
-	void
-	windowNotify (CompWindowNotify);
+	void windowNotify (CompWindowNotify n);
 
 };
 
-/* Most plugins set up macros to access their Screen and Window classes based on a CompScreen * or CompWindow * */
-
 #define EX_SCREEN (screen) \
 UnityScreen *es = UnityScreen::get (screen);
 
@@ -295,15 +178,10 @@
  */
 
 class UnityPluginVTable :
-    /* Inheriting CompPlugin::VTableForScreenAndWindow <ScreenClass, WindowClass>
-     * automatically does most of the vTable setup for you */
     public CompPlugin::VTableForScreenAndWindow<UnityScreen, UnityWindow>
 {
     public:
 
-	/* You MUST have this function. Compiz calls this function first off and that
-	 * is what kick-starts your initialization procedure. It must be named
-	 * _exactly_ init too */
-
+	/* kickstart initialization */
 	bool init ();
 };

=== modified file 'unityshell.xml.in'
--- unityshell.xml.in	2010-11-12 10:58:04 +0000
+++ unityshell.xml.in	2010-11-25 16:12:10 +0000
@@ -5,7 +5,30 @@
 	<_long>Plugin to draw the Unity Shell</_long>
 	<deps>
 	    <relation type="after">
+		<plugin>bailer</plugin>
+		<plugin>detection</plugin>
+		<plugin>composite</plugin>
+		<plugin>opengl</plugin>
+		<plugin>mousepoll</plugin>
+		<plugin>move</plugin>
+		<plugin>resize</plugin>
 		<plugin>decor</plugin>
+		<plugin>compiztoolbox</plugin>
+		<plugin>place</plugin>
+		<plugin>session</plugin>
+		<plugin>animation</plugin>
+		<plugin>regex</plugin>
+		<plugin>cube</plugin>
+		<plugin>rotate</plugin>
+		<plugin>cubeaddon</plugin>
+		<plugin>gnomecompat</plugin>
+		<plugin>vpswitch</plugin>
+		<plugin>fade</plugin>
+		<plugin>staticswitcher</plugin>
+		<plugin>scale</plugin>
+		<plugin>expo</plugin>
+		<plugin>ezoom</plugin>
+		<plugin>wall</plugin>
 	    </relation>
 	    <requirement>
 		<plugin>opengl</plugin>