Merge lp:~smspillaz/compiz-core/compiz-core.fix_900580 into lp:compiz-core/0.9.5

[Sam Spilsbury]

Adds a parser and scriptable standalone wm part for testing

Next pipe: lp:~smspillaz/compiz-core/fix-903529

[Alan Griffiths (alan-griffiths)]

The class ManagedStateBit is strange:
  o there are inline functions defined in the .cpp file - so is the class usable elsewhere?
  o in general, symmetric operators should be non-member functions.
  o are all these operators needed? The implicit conversion uint64_t to ought to cover most uses?
  o why isn't operator uint64_t() inline? (and in the header?)

What is the purpose of the Visitor class:
  o it clearly isn't part of a GOF "Visitor" pattern;
  o it doesn't appear to be used; and,
  o it just provides a level of indirection to calling similarly named functions on it's member.

review: Needs Information

[Alan Griffiths (alan-griffiths)]

The issues with src/managedstatebit.cpp are unchanged.

review: Needs Fixing

[lp:~smspillaz/compiz-core/compiz-core.fix_900580]

2996. By Sam Spilsbury on 2012-01-13

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

[Alan Griffiths (alan-griffiths)]

> The class ManagedStateBit is strange:
> o there are inline functions defined in the .cpp file - so is the class usable elsewhere?
> o in general, symmetric operators should be non-member functions.
> o are all these operators needed? The implicit conversion uint64_t to ought to cover most uses?
> o why isn't operator uint64_t() inline? (and in the header?)

Looked a bit closer:

The mutating operators do not need ManagedStateBit overloads as the "operator uint64_t() const" (which should be inline and in the header) and the corresponding uint64_t overloads provide the same functionality. The non-mutating operators are not needed as the uint64_t conversion operator with normal operations on uint64_t provide the same functionality.

(With that change there are no symmetric ops left to make non-members.)

On the face of it there is only ever one instance of this class - a public, static member variable of Object. Global data is usually a bad idea - and I don't see what justifies this case.

review: Needs Fixing

[lp:~smspillaz/compiz-core/compiz-core.fix_900580]

2997. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

2998. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

2999. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3000. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3001. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3002. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3003. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3004. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3005. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3006. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3007. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

Unmerged revisions

3007. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3006. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3005. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3004. By Sam Spilsbury on 2012-01-19

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3003. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3002. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3001. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

3000. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

2999. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

2998. By Sam Spilsbury on 2012-01-18

Merged compiz-core.merge_894639 into compiz-core.fix_900580.

=== modified file 'include/core/CMakeLists.txt'
--- include/core/CMakeLists.txt	2012-01-19 18:25:05 +0000
+++ include/core/CMakeLists.txt	2012-01-19 18:25:06 +0000
@@ -12,6 +12,7 @@
     icon.h
     match.h
     modifierhandler.h
+    managedstatebit.h
     object.h
     option.h
     output.h

=== modified file 'include/core/asynchronous-container.h'
--- include/core/asynchronous-container.h	2012-01-19 18:25:05 +0000
+++ include/core/asynchronous-container.h	2012-01-19 18:25:06 +0000
@@ -42,7 +42,7 @@
 class ReadServerConnection;
 
 class AsynchronousContainer :
-    public AsynchronousObject,
+    virtual public AsynchronousObject,
     public Container
 {
     public:
@@ -76,6 +76,12 @@
 	void receiveInsertion (const Object::Ptr &);
 	void receiveRemoval   (const Object::Ptr &);
 
+	virtual void onReceiveInsertion (const Object::Ptr &) {};
+	virtual void onReceiveRemoval (const Object::Ptr &) {};
+
+	virtual void onSendInsertion (const Object::Ptr &) {};
+	virtual void onSendRemoval (const Object::Ptr &) {};
+
 	void        addSentInsertion (const Object::Ptr &);
 	Object::Ptr addSentRemoval   (const Object::Ptr &);
 

=== modified file 'include/core/asynchronous-object.h'
--- include/core/asynchronous-object.h	2012-01-19 18:25:05 +0000
+++ include/core/asynchronous-object.h	2012-01-19 18:25:06 +0000
@@ -66,18 +66,35 @@
 	/* Most recent sent positions */
 	const compiz::window::Geometry      &sentGeometry () const;
 	const compiz::window::StackPosition &sentStackPosition () const;
+	const uint64_t			    &sendState () const;
 
 	void sendGeometry      (const compiz::window::Geometry &);
 	void sendStackPosition (const compiz::window::StackPosition &);
+	void sendAddState      (uint64_t state);
+	void sendRemoveState   (uint64_t state);
 
     protected:
 
 	void receiveGeometry      (const compiz::window::Geometry &);
 	void receiveStackPosition (const compiz::window::StackPosition &);
-	//void receiveMap ();
+	void receiveState         (uint64_t addState, uint64_t removeState);
 
 	void addSentGeometry      (const compiz::window::Geometry &);
 	void addSentStackPosition (const compiz::window::StackPosition &);
+	void addSentAddedState (uint64_t aState);
+	void addSentRemovedState (uint64_t rState);
+
+	virtual void onReceiveGeometry (const compiz::window::Geometry &) {};
+	virtual void onReceiveStackPosition (const compiz::window::StackPosition &) {};
+	virtual void onReceiveDeletion () {};
+	virtual void onReceiveAddState (uint64_t) {}
+	virtual void onReceiveRemoveState (uint64_t) {}
+
+	virtual void onSendGeometry (const compiz::window::Geometry &) {};
+	virtual void onSendStackPosition  (const compiz::window::StackPosition &) {};
+	virtual void onSendDeletion () {};
+	virtual void onSendAddState (uint64_t) {}
+	virtual void onSendRemoveState (uint64_t) {}
 
 	boost::shared_ptr <WriteServerConnection> mWriteConnection;
 
@@ -87,6 +104,7 @@
 
 	compiz::window::Geometry	           mSentGeometry;
 	compiz::window::StackPosition	           mSentStackPosition;
+	uint64_t				   mSentState;
 };
 }
 }

=== modified file 'include/core/asynchronous-server.h'
--- include/core/asynchronous-server.h	2012-01-19 18:25:05 +0000
+++ include/core/asynchronous-server.h	2012-01-19 18:25:06 +0000
@@ -36,6 +36,7 @@
 #include <core/stackposition.h>
 #include <core/object.h>
 #include <glibmm/main.h>
+#include <stdint.h>
 
 namespace compiz
 {
@@ -44,9 +45,20 @@
 
 class WriteServerConnection;
 
+class ObjectCreationRequest
+{
+    public:
+
+	typedef boost::shared_ptr <ObjectCreationRequest> Ptr;
+	virtual ~ObjectCreationRequest ();
+    protected:
+
+	ObjectCreationRequest ();
+};
+
+
 class AsynchronousServer :
-    public Server,
-    public boost::enable_shared_from_this <AsynchronousServer>
+    public Server
 {
     public:
 
@@ -54,8 +66,11 @@
 
 	virtual ~AsynchronousServer ();
 
+	static const unsigned int BlockUntilCompletion = (1 << 0);
+	static const unsigned int DiscardGeneratedEvents = (1 << 0);
+
 	boost::shared_ptr <WriteServerConnection> connect ();
-
+	void					  flush (unsigned int);
     protected:
 
 	AsynchronousServer ();
@@ -67,10 +82,21 @@
 	virtual void sendParent (const ObjectIdentifier::Ptr &,
 				 const ObjectIdentifier::Ptr &) = 0;
 
+	virtual void sendCreateObject (const boost::shared_ptr <ObjectCreationRequest> &) = 0;
+	virtual void sendDeleteObject (const ObjectIdentifier::Ptr &) = 0;
+	virtual void sendState (const ObjectIdentifier::Ptr &, uint64_t aState, uint64_t rState) = 0;
+
+	virtual void dispatchRequests (unsigned int) = 0;
+
+	void setEventSource (const Glib::RefPtr <Glib::Source> &);
+
 	compiz::window::ReadServerConnection::Ptr   mReadConnection;
+
+	friend class WriteServerConnection;
+
+    private:
+
 	Glib::RefPtr <Glib::Source>		    mEventSource;
-
-	friend class WriteServerConnection;
 };
 
 }

=== modified file 'include/core/container.h'
--- include/core/container.h	2012-01-19 18:25:05 +0000
+++ include/core/container.h	2012-01-19 18:25:06 +0000
@@ -38,7 +38,8 @@
 {
 
 class Container :
-    virtual public Object
+    virtual public Object,
+    public boost::enable_shared_from_this <Container>
 {
     public:
 

=== added file 'include/core/managedstatebit.h'
--- include/core/managedstatebit.h	1970-01-01 00:00:00 +0000
+++ include/core/managedstatebit.h	2012-01-19 18:25:06 +0000
@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ */
+
+#ifndef _COMPIZ_MANAGED_STATE_BIT_H
+#define _COMPIZ_MANAGED_STATE_BIT_H
+
+#include <stdint.h>
+#include <boost/noncopyable.hpp>
+#include <vector>
+
+namespace compiz
+{
+namespace window
+{
+
+/**
+ * Static class of managed states
+ */
+class ManagedStates
+{
+    public:
+
+	static bool registerState (uint64_t &stateBit);
+	static bool unregisterState (uint64_t &stateBit);
+
+    private:
+
+	ManagedStates () {};
+	~ManagedStates () {};
+
+	/* singleton state bit base
+	 * use this to determine the number
+	 * of state bits remaining for implementations
+	 * to use. The protected functions registerState
+	 * and unregisterState will manage free space
+	 * in the state bits */
+	static uint64_t stateBase;
+
+	/* The vector keeps track of pointers to all
+	 * of the state bit identifiers, they are modified
+	 * at runtime depending on free space within
+	 * the state base */
+	static std::vector <uint64_t *> managedStateBits;
+};
+
+/**
+ * An RAII managed state bit definition class,
+ * by holding an instance of this class, a unique
+ * bitmask is registered with the singleton list
+ * in Object which is used to identify a particular
+ * state of the object. The actual value of the
+ * underlying bitmask can change depending on the free
+ * space in the total number of bits available in Object */
+class ManagedStateBit :
+    boost::noncopyable
+{
+    public:
+
+	ManagedStateBit ();
+	~ManagedStateBit ();
+
+	inline uint64_t operator~ () const;
+	inline uint64_t operator& (const uint64_t &i) const;
+	inline uint64_t operator& (const ManagedStateBit &b) const;
+	inline uint64_t operator| (const uint64_t &i) const;
+	inline uint64_t operator| (const ManagedStateBit &b) const;
+	inline uint64_t operator^ (const uint64_t &i) const;
+	inline uint64_t operator^ (const ManagedStateBit &b) const;
+
+	inline uint64_t operator&= (const uint64_t &i);
+	inline uint64_t operator&= (const ManagedStateBit &b);
+	inline uint64_t operator|= (const uint64_t &i);
+	inline uint64_t operator|= (const ManagedStateBit &b);
+	inline uint64_t operator^= (const uint64_t &i);
+	inline uint64_t operator^= (const ManagedStateBit &b);
+
+	inline bool operator== (const uint64_t &i) const;
+	inline bool operator== (const ManagedStateBit &b) const;
+	inline bool operator!= (const uint64_t &i) const;
+	inline bool operator!= (const ManagedStateBit &b) const;
+
+	operator uint64_t () const;
+    private:
+
+	uint64_t mStateBit;
+};
+
+}
+}
+
+#endif

=== modified file 'include/core/object.h'
--- include/core/object.h	2012-01-19 18:25:05 +0000
+++ include/core/object.h	2012-01-19 18:25:06 +0000
@@ -30,7 +30,9 @@
 #include <boost/shared_ptr.hpp>
 #include <core/windowgeometry.h>
 #include <core/stackposition.h>
+#include <core/managedstatebit.h>
 #include <boost/enable_shared_from_this.hpp>
+#include <stdint.h>
 
 namespace compiz
 {
@@ -65,16 +67,16 @@
 	bool operator== (const ObjectIdentifier::Ptr &) const;
 	bool operator!= (const ObjectIdentifier::Ptr &) const;
 
-	bool equal (const ObjectIdentifier::Ptr &) const;
+	bool		   equal (const ObjectIdentifier::Ptr &) const;
 
-	const boost::shared_ptr <Object> & operator() ();
-	const boost::shared_ptr <Object> & operator() () const;
+	boost::shared_ptr <Object> operator() ();
+	boost::shared_ptr <Object> operator() () const;
 
     protected:
 
 	virtual bool compare (const ObjectIdentifier::Ptr &) const = 0;
 	virtual ObjectType getType () const = 0;
-	virtual const boost::shared_ptr <Object> & lookup () const = 0;
+	virtual boost::shared_ptr <Object> lookup () const = 0;
 
 	/* Either fully resolved or looked up
 	 * at runtime in the repository */
@@ -83,12 +85,35 @@
 	friend class Server;
 };
 
-class Object
+class ObjectKey
+{
+};
+
+class Object :
+    boost::noncopyable
 {
     public:
 
 	typedef boost::shared_ptr <Object> Ptr;
 
+	class Visitor :
+	    boost::noncopyable
+	{
+	    public:
+
+		Visitor (ObjectKey const &, const compiz::window::Object::Ptr &o);
+		virtual ~Visitor ();
+
+	    protected:
+		bool setStackPosition (const StackPosition &);
+		bool setGeometry (const Geometry &);
+		bool setContainer (const boost::shared_ptr <Container> &);
+		bool addState (const uint64_t &state);
+		bool removeState (const uint64_t &state);
+	    private:
+		compiz::window::Object::Ptr mObject;
+	};
+
 	Object (const ObjectIdentifier::Ptr &);
 	Object (const ObjectIdentifier::Ptr &,
 		const compiz::window::Geometry &);
@@ -106,16 +131,23 @@
 	const ObjectIdentifier::Ptr & id () const;
 	const compiz::window::Geometry & geometry () const;
 	const compiz::window::StackPosition & stackPosition () const;
+	const uint64_t & state () const;
 
 	bool operator== (const Object &) const;
 	bool operator!= (const Object &) const;
 
+	/* state bits for this */
+	static ManagedStateBit StateMapped;
+
     protected:
 
+	/* Returns true if anything was actually changed */
 	bool setStackPosition (const StackPosition &);
 	bool setGeometry (const Geometry &);
-	//virtual bool show () = 0;
-	//virtual bool hide () = 0;
+	bool setContainer (const boost::shared_ptr <Container> &);
+	bool setVisible (bool);
+	bool addState (const uint64_t &state);
+	bool removeState (const uint64_t &state);
 
     private:
 
@@ -123,6 +155,9 @@
 	compiz::window::Geometry		      mGeometry;
 	compiz::window::StackPosition		      mStackPosition;
 	boost::shared_ptr <Container>		      mContainer;
+	uint64_t				      mState;
+
+
 };
 
 class SynchronousObject :
@@ -146,6 +181,7 @@
 
 	bool setStackPosition (const StackPosition &);
 	bool setGeometry (const Geometry &);
+	bool setState (const uint64_t &state);
 };
 
 }

=== modified file 'include/core/server-read.h'
--- include/core/server-read.h	2012-01-19 18:25:05 +0000
+++ include/core/server-read.h	2012-01-19 18:25:06 +0000
@@ -34,6 +34,7 @@
 #include <core/object.h>
 #include <core/asynchronous-object.h>
 #include <core/asynchronous-container.h>
+#include <stdint.h>
 
 namespace compiz
 {
@@ -58,6 +59,10 @@
 
 	void receiveParent (const AsynchronousObject::Ptr    &,
 			    const AsynchronousContainer::Ptr &);
+
+	void receiveState (const AsynchronousObject::Ptr     &,
+			   uint64_t                          addState,
+			   uint64_t			     removeState);
     protected:
 
 	ReadServerConnection ();

=== modified file 'include/core/server-write.h'
--- include/core/server-write.h	2012-01-19 18:25:05 +0000
+++ include/core/server-write.h	2012-01-19 18:25:06 +0000
@@ -39,6 +39,8 @@
 namespace window
 {
 
+class ObjectCreationRequest;
+
 class WriteServerConnection :
     public boost::noncopyable
 {
@@ -55,6 +57,15 @@
 
 	void sendParent (const ObjectIdentifier::Ptr  &id,
 			 const ObjectIdentifier::Ptr  &parent);
+
+	void sendCreateObject (const ObjectCreationRequest::Ptr &req);
+
+	void sendDeleteObject (const ObjectIdentifier::Ptr &id);
+
+	void sendState (const ObjectIdentifier::Ptr &id,
+			uint64_t		    aState,
+			uint64_t		    rState);
+
     private:
 
 	WriteServerConnection (const compiz::window::AsynchronousServer::Ptr &);

=== modified file 'include/core/server.h'
--- include/core/server.h	2012-01-19 18:25:05 +0000
+++ include/core/server.h	2012-01-19 18:25:06 +0000
@@ -29,7 +29,9 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/noncopyable.hpp>
+#include <boost/enable_shared_from_this.hpp>
 #include <core/object.h>
+#include <core/container.h>
 
 namespace compiz
 {
@@ -37,6 +39,7 @@
 {
 
 class Server :
+    public boost::enable_shared_from_this <Server>,
     public boost::noncopyable
 {
     public:
@@ -45,18 +48,30 @@
 	virtual ~Server ();
 
 	const Object::Ptr & root ();
-	virtual const Object::Ptr & lookup (const boost::shared_ptr <const ObjectIdentifier> &id) = 0;
+	virtual Object::Ptr lookup (const boost::shared_ptr <const ObjectIdentifier> &id) const = 0;
 
 	static Server::Ptr Default ();
 
     protected:
 
 	Server ();
+	static void SetDefault (Server::Ptr s);
+
+	void setRoot (const compiz::window::Object::Ptr &root);
+
+	virtual compiz::window::Object::Ptr
+	createObject (const compiz::window::ObjectIdentifier::Ptr &id,
+		      const compiz::window::Geometry              &g = compiz::window::Geometry (),
+		      const compiz::window::StackPosition         &sp = compiz::window::StackPosition (),
+		      const compiz::window::Container::Ptr        &c = boost::shared_polymorphic_cast <compiz::window::Container> (Server::Default ()->root ())) = 0;
+
+	virtual void
+	removeObject (const compiz::window::ObjectIdentifier::Ptr &) = 0;
 
     private:
 
+	static Server::Ptr mDefault;
 	Object::Ptr        mRoot;
-	static Server::Ptr mDefault;
 };
 
 }

=== added file 'include/core/x11-object.h'
--- include/core/x11-object.h	1970-01-01 00:00:00 +0000
+++ include/core/x11-object.h	2012-01-19 18:25:06 +0000
@@ -0,0 +1,116 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ */
+
+#ifndef _COMPIZ_X11_OBJECT_H
+#define _COMPIZ_X11_OBJECT_H
+
+#include <core/object.h>
+#include <core/asynchronous-object.h>
+#include <core/asynchronous-container.h>
+#include <core/windowgeometry.h>
+#include <X11/Xlib.h>
+#include <boost/shared_ptr.hpp>
+
+namespace compiz
+{
+namespace window
+{
+
+class X11Server;
+class X11ObjectIdentifier;
+class WriteServerConnection;
+
+class X11ObjectIdentifier :
+    public ObjectIdentifier
+{
+    public:
+
+	typedef boost::shared_ptr <X11ObjectIdentifier>	      Ptr;
+	typedef boost::shared_ptr <const X11ObjectIdentifier> ConstPtr;
+
+	X11ObjectIdentifier (Window id);
+	~X11ObjectIdentifier ();
+
+	void print ();
+
+    protected:
+
+	compiz::window::ObjectIdentifier::ObjectType  getType () const;
+	bool					      compare (const ObjectIdentifier::Ptr &) const;
+	compiz::window::Object::Ptr		      lookup () const;
+
+    private:
+
+        Window mId;
+
+	friend class X11Server;
+};
+
+
+class X11Object :
+    virtual public AsynchronousObject
+{
+    public:
+
+	typedef boost::shared_ptr <X11Object> Ptr;
+
+	virtual ~X11Object ();
+
+    protected:
+
+	X11Object (const ObjectIdentifier::Ptr			      &,
+		   const boost::shared_ptr <WriteServerConnection>    &,
+		   const compiz::window::Geometry		      &,
+		   const boost::shared_ptr <Container>		      &);
+
+	friend class X11Server;
+};
+
+class X11Container :
+    public AsynchronousContainer,
+    public X11Object
+{
+    public:
+
+	typedef boost::shared_ptr <X11Container> Ptr;
+
+	virtual ~X11Container ();
+
+    protected:
+
+	X11Container (const ObjectIdentifier::Ptr			 &,
+		      const boost::shared_ptr <WriteServerConnection>    &,
+		      const compiz::window::Geometry			 &,
+		      const boost::shared_ptr <Container>		 &);
+
+	friend class X11Server;
+
+};
+
+}
+}
+
+#endif

=== added file 'include/core/x11-server.h'
--- include/core/x11-server.h	1970-01-01 00:00:00 +0000
+++ include/core/x11-server.h	2012-01-19 18:25:06 +0000
@@ -0,0 +1,140 @@
+/*
+ * Copyright © 2011 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ */
+
+#ifndef _COMPIZ_X11_SERVER_H
+#define _COMPIZ_X11_SERVER_H
+
+#include <core/server.h>
+#include <core/asynchronous-server.h>
+#include <core/x11-object.h>
+#include <boost/shared_ptr.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/functional/hash.hpp>
+#include <X11/Xlib.h>
+
+
+namespace compiz
+{
+namespace window
+{
+void populateXWindowChanges (const compiz::window::Geometry &g,
+			     unsigned int                   mask,
+			     XWindowChanges                 &xwc);
+
+void populateXWindowChanges (const compiz::window::StackPosition &sp,
+			     unsigned int                        mask,
+			     XWindowChanges                      &xwc);
+
+class X11ObjectCreationRequest :
+    public compiz::window::ObjectCreationRequest
+{
+    public:
+
+	typedef boost::shared_ptr <X11ObjectCreationRequest> Ptr;
+
+	X11ObjectCreationRequest (XSetWindowAttributes				 &attr,
+				  const compiz::window::Geometry		 &g,
+				  unsigned int					 cclass,
+				  unsigned int					 depth,
+				  const compiz::window::X11ObjectIdentifier::Ptr &parent,
+				  unsigned int                                   attrValueMask,
+				  Visual                                         *vis);
+
+	virtual ~X11ObjectCreationRequest ();
+
+	inline XSetWindowAttributes			      & attributes () const;
+	inline const compiz::window::Geometry		      & geometry () const;
+	inline const unsigned int			      & cclass () const;
+	inline const unsigned int			      & depth () const;
+	inline const compiz::window::X11ObjectIdentifier::Ptr & parent () const;
+	inline const unsigned int                             & attrValueMask () const;
+	inline Visual					      * visual () const;
+
+    private:
+
+	mutable XSetWindowAttributes		       mAttr;
+	compiz::window::Geometry		       mGeometry;
+	unsigned int				       mClass;
+	unsigned int				       mDepth;
+	compiz::window::X11ObjectIdentifier::Ptr       mParent;
+	unsigned int                                   mAttrValueMask;
+	Visual					       *mVis;
+};
+
+class X11Server :
+    public AsynchronousServer
+{
+    public:
+
+	typedef boost::shared_ptr <X11Server> Ptr;
+
+	virtual ~X11Server ();
+
+	Object::Ptr lookup (const boost::shared_ptr <const ObjectIdentifier> &id) const;
+
+    protected:
+
+	X11Server ();
+	X11Server (const char *);
+	X11Server (Display *);
+
+	void sendGeometry (const ObjectIdentifier::Ptr    &,
+			   const compiz::window::Geometry &);
+
+	void sendStackPosition (const ObjectIdentifier::Ptr         &,
+				const compiz::window::StackPosition &);
+
+	void sendParent (const ObjectIdentifier::Ptr &child,
+			 const ObjectIdentifier::Ptr &parent);
+
+	void sendCreateObject (const boost::shared_ptr <ObjectCreationRequest> &req);
+
+	void sendDeleteObject (const ObjectIdentifier::Ptr &id);
+
+	void sendState (const ObjectIdentifier::Ptr &id, uint64_t aState, uint64_t rState);
+
+	void dispatchRequests (unsigned int);
+
+	void setupEventSource ();
+	void setRoot (Window root, const Geometry &);
+
+	void addObjectToTree (const std::pair <X11ObjectIdentifier::Ptr,
+					       X11Object::Ptr       > &);
+	void removeKeyFromTree (const ObjectIdentifier::Ptr &);
+
+    private:
+
+	void dispatchEvent (XEvent *);
+	void queueEvents ();
+
+	boost::unordered_map <Window, X11Object::Ptr> mObjectTree;
+	Display					      *mDisplay;
+};
+
+}
+}
+
+#endif

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2012-01-19 18:25:05 +0000
+++ src/CMakeLists.txt	2012-01-19 18:25:06 +0000
@@ -110,6 +110,10 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/server-write.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/stack.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/asynchronous-stack.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/x11-object.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/x11-container.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/x11-server.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/managedstatebit.cpp
     ${_bcop_sources}
 )
 

=== modified file 'src/asynchronous-container.cpp'
--- src/asynchronous-container.cpp	2012-01-19 18:25:05 +0000
+++ src/asynchronous-container.cpp	2012-01-19 18:25:06 +0000
@@ -27,11 +27,28 @@
 #include <core/server-write.h>
 #include <core/server.h>
 
+class AsynchronousObjectContainerVisitor :
+    public compiz::window::Object::Visitor
+{
+    public:
+	AsynchronousObjectContainerVisitor (const compiz::window::ObjectKey   &k,
+					    const compiz::window::Object::Ptr &p) :
+	    compiz::window::Object::Visitor (k, p)
+	{
+	}
+
+	inline bool changeContainer (const compiz::window::Container::Ptr & c)
+	{
+	    return setContainer (c);
+	}
+};
+
 compiz::window::AsynchronousContainer::AsynchronousContainer (const compiz::window::ObjectIdentifier::Ptr      &id,
 							      const compiz::window::WriteServerConnection::Ptr &writer) :
     Object::Object (id),
     AsynchronousObject::AsynchronousObject (id, writer),
-    Container::Container (id)
+    Container::Container (id),
+    mWriteConnection (writer)
 {
 }
 
@@ -40,7 +57,8 @@
 							      const compiz::window::WriteServerConnection::Ptr &writer) :
     Object::Object (id, g),
     AsynchronousObject::AsynchronousObject (id, g, writer),
-    Container::Container (id, g)
+    Container::Container (id, g),
+    mWriteConnection (writer)
 {
 }
 
@@ -50,7 +68,8 @@
 							      const compiz::window::WriteServerConnection::Ptr &writer) :
     Object::Object (id, g, sp),
     AsynchronousObject::AsynchronousObject (id, g, sp, writer),
-    Container::Container (id, g, sp)
+    Container::Container (id, g, sp),
+    mWriteConnection (writer)
 {
 }
 
@@ -61,7 +80,8 @@
 							      const compiz::window::WriteServerConnection::Ptr &writer) :
     Object::Object (id, g, sp, c),
     AsynchronousObject::AsynchronousObject (id, g, sp , c, writer),
-    Container::Container (id, g, sp, c)
+    Container::Container (id, g, sp, c),
+    mWriteConnection (writer)
 {
 }
 
@@ -72,6 +92,8 @@
 void
 compiz::window::AsynchronousContainer::sendInsertion (const Object::Ptr &o)
 {
+    onSendInsertion (o);
+
     mWriteConnection->sendParent (o->id (), id ());
 
     addSentInsertion (o);
@@ -80,23 +102,35 @@
 compiz::window::Object::Ptr
 compiz::window::AsynchronousContainer::sendRemoval (const Object::Ptr &o)
 {
+    onSendRemoval (o);
+
+    mWriteConnection->sendParent (o->id (), Server::Default ()->root ()->id ());
+
     Object::Ptr p = addSentRemoval (o);
 
-    mWriteConnection->sendParent (o->id (), Server::Default ()->root ()->id ());
-
     return p;
 }
 
 void
 compiz::window::AsynchronousContainer::receiveInsertion (const Object::Ptr &o)
 {
+    compiz::window::ObjectKey	       k;
+    AsynchronousObjectContainerVisitor v (k, o);
+    onReceiveInsertion (o);
+
     Container::insert (o);
+    v.changeContainer (Container::shared_from_this ());
 }
 
 void
 compiz::window::AsynchronousContainer::receiveRemoval (const Object::Ptr &o)
 {
+    compiz::window::ObjectKey	       k;
+    AsynchronousObjectContainerVisitor v (k, o);
+    onReceiveRemoval (o);
+
     Container::remove (o);
+    v.changeContainer (Container::Ptr ());
 }
 
 void

=== modified file 'src/asynchronous-object.cpp'
--- src/asynchronous-object.cpp	2012-01-19 18:25:05 +0000
+++ src/asynchronous-object.cpp	2012-01-19 18:25:06 +0000
@@ -76,9 +76,17 @@
     return mSentStackPosition;
 }
 
+const uint64_t &
+compiz::window::AsynchronousObject::sendState () const
+{
+    return mSentState;
+}
+
 void
 compiz::window::AsynchronousObject::sendGeometry (const compiz::window::Geometry &g)
 {
+    onSendGeometry (g);
+
     mWriteConnection->sendGeometry (id (), g);
 
     addSentGeometry (g);
@@ -87,24 +95,61 @@
 void
 compiz::window::AsynchronousObject::sendStackPosition (const compiz::window::StackPosition &sp)
 {
+    onSendStackPosition (sp);
+
     mWriteConnection->sendStackPosition (id (), sp);
 
     addSentStackPosition (sp);
 }
 
 void
+compiz::window::AsynchronousObject::sendAddState (uint64_t aState)
+{
+    onSendAddState (aState);
+
+    mWriteConnection->sendState (id (), aState & ~mSentState, 0);
+
+    addSentAddedState (aState);
+}
+
+void
+compiz::window::AsynchronousObject::sendRemoveState (uint64_t rState)
+{
+    onSendRemoveState (rState);
+
+    mWriteConnection->sendState (id (), 0, rState & mSentState);
+
+    addSentRemovedState (rState);
+}
+
+void
 compiz::window::AsynchronousObject::receiveGeometry (const compiz::window::Geometry &g)
 {
+    onReceiveGeometry (g);
+
     Object::setGeometry (g);
 }
 
 void
 compiz::window::AsynchronousObject::receiveStackPosition (const compiz::window::StackPosition &sp)
 {
+    onReceiveStackPosition (sp);
+
     Object::setStackPosition (sp);
 }
 
 void
+compiz::window::AsynchronousObject::receiveState (uint64_t addState,
+						  uint64_t removeState)
+{
+    onReceiveAddState (addState);
+    onReceiveRemoveState (removeState);
+
+    Object::addState (addState);
+    Object::removeState (removeState);
+}
+
+void
 compiz::window::AsynchronousObject::addSentGeometry (const compiz::window::Geometry &g)
 {
     mSentGeometry = g;
@@ -115,3 +160,15 @@
 {
     mSentStackPosition = sp;
 }
+
+void
+compiz::window::AsynchronousObject::addSentAddedState (uint64_t aState)
+{
+    mSentState |= aState;
+}
+
+void
+compiz::window::AsynchronousObject::addSentRemovedState (uint64_t rState)
+{
+    mSentState &= ~rState;
+}

=== modified file 'src/asynchronous-server.cpp'
--- src/asynchronous-server.cpp	2012-01-19 18:25:05 +0000
+++ src/asynchronous-server.cpp	2012-01-19 18:25:06 +0000
@@ -26,6 +26,14 @@
 #include <core/asynchronous-server.h>
 #include <core/server-write.h>
 
+compiz::window::ObjectCreationRequest::ObjectCreationRequest ()
+{
+}
+
+compiz::window::ObjectCreationRequest::~ObjectCreationRequest ()
+{
+}
+
 compiz::window::AsynchronousServer::AsynchronousServer () :
     Server::Server (),
     mReadConnection (new compiz::window::ReadServerConnection)
@@ -36,10 +44,26 @@
 {
 }
 
+void
+compiz::window::AsynchronousServer::setEventSource (const Glib::RefPtr <Glib::Source> &source)
+{
+    const Glib::RefPtr <Glib::MainContext> &mc = Glib::MainContext::get_default ();
+    mEventSource = source;
+
+    mEventSource->attach (mc);
+}
+
 compiz::window::WriteServerConnection::Ptr
 compiz::window::AsynchronousServer::connect ()
 {
-    compiz::window::AsynchronousServer::Ptr t = shared_from_this ();
+    compiz::window::AsynchronousServer::Ptr t =
+	    boost::shared_static_cast <compiz::window::AsynchronousServer> (shared_from_this ());
     return compiz::window::WriteServerConnection::Ptr (new compiz::window::WriteServerConnection (t));
 }
 
+void
+compiz::window::AsynchronousServer::flush (unsigned int flags)
+{
+    dispatchRequests (flags);
+}
+

=== modified file 'src/container.cpp'
--- src/container.cpp	2012-01-19 18:25:05 +0000
+++ src/container.cpp	2012-01-19 18:25:06 +0000
@@ -78,7 +78,9 @@
     if (it != mChildren.end ())
 	return false;
     else
+    {
 	mChildren.insert (it, o);
+    }
 
     return true;
 }

=== modified file 'src/eventsource.cpp'
--- src/eventsource.cpp	2012-01-19 18:25:05 +0000
+++ src/eventsource.cpp	2012-01-19 18:25:06 +0000
@@ -68,6 +68,7 @@
 CompEventSource::callback ()
 {
     mProcEvents ();
+    XFlush (mDpy);
     return true;
 }
 

=== added file 'src/managedstatebit.cpp'
--- src/managedstatebit.cpp	1970-01-01 00:00:00 +0000
+++ src/managedstatebit.cpp	2012-01-19 18:25:06 +0000
@@ -0,0 +1,173 @@
+/*
+ * Copyright © 2010 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <core/managedstatebit.h>
+#include <core/object.h>
+#include <boost/bind.hpp>
+
+uint64_t compiz::window::ManagedStates::stateBase = (1 << 0);
+std::vector <uint64_t *> compiz::window::ManagedStates::managedStateBits = std::vector <uint64_t *> ();
+
+bool
+compiz::window::ManagedStates::registerState (uint64_t &state)
+{
+    managedStateBits.push_back (&state);
+    state = stateBase;
+    stateBase <<= 1;
+
+    /* FIXME: check for overflow */
+    return true;
+}
+
+static bool
+findIfMatchingUINT64Ptr (uint64_t       *p,
+			 const uint64_t &v)
+{
+    return *p == v;
+}
+
+bool
+compiz::window::ManagedStates::unregisterState (uint64_t &state)
+{
+    std::vector <uint64_t *>::iterator it = std::find_if (managedStateBits.begin (),
+							  managedStateBits.end (),
+							  boost::bind (findIfMatchingUINT64Ptr, _1, state));
+
+    if (it != managedStateBits.end ())
+    {
+	it = managedStateBits.erase (it);
+
+	/* Shift all other bits down one */
+	while (it != managedStateBits.end ())
+	{
+	    (*(*it)) >>= 1;
+	    it++;
+	}
+
+	return true;
+    }
+
+    return false;
+}
+
+compiz::window::ManagedStateBit::ManagedStateBit ()
+{
+    compiz::window::ManagedStates::registerState (mStateBit);
+}
+
+compiz::window::ManagedStateBit::~ManagedStateBit ()
+{
+    compiz::window::ManagedStates::unregisterState (mStateBit);
+}
+
+uint64_t compiz::window::ManagedStateBit::operator~ () const
+{
+    return ~mStateBit;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator& (const uint64_t &i) const
+{
+    return mStateBit & i;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator& (const ManagedStateBit &b) const
+{
+    return mStateBit & b.mStateBit;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator| (const uint64_t &i) const
+{
+    return mStateBit | i;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator| (const ManagedStateBit &b) const
+{
+    return mStateBit | b.mStateBit;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator^ (const uint64_t &i) const
+{
+    return mStateBit ^ i;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator^ (const ManagedStateBit &b) const
+{
+    return mStateBit ^ b.mStateBit;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator&= (const uint64_t &i)
+{
+    return mStateBit |= i;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator&= (const ManagedStateBit &b)
+{
+    return mStateBit |= b.mStateBit;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator|= (const uint64_t &i)
+{
+    return mStateBit |= i;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator|= (const ManagedStateBit &b)
+{
+    return mStateBit |= b.mStateBit;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator^= (const uint64_t &i)
+{
+    return mStateBit ^= i;
+}
+
+uint64_t compiz::window::ManagedStateBit::operator^= (const ManagedStateBit &b)
+{
+    return mStateBit ^= b.mStateBit;
+}
+
+bool compiz::window::ManagedStateBit::operator== (const uint64_t &i) const
+{
+    return mStateBit == i;
+}
+
+bool compiz::window::ManagedStateBit::operator!= (const uint64_t &i) const
+{
+    return mStateBit != i;
+}
+
+bool compiz::window::ManagedStateBit::operator== (const ManagedStateBit &b) const
+{
+    return mStateBit == b.mStateBit;
+}
+
+bool compiz::window::ManagedStateBit::operator!= (const ManagedStateBit &b) const
+{
+    return mStateBit != b.mStateBit;
+}
+
+compiz::window::ManagedStateBit::operator uint64_t() const
+{
+    return mStateBit;
+}

=== modified file 'src/object.cpp'
--- src/object.cpp	2012-01-19 18:25:05 +0000
+++ src/object.cpp	2012-01-19 18:25:06 +0000
@@ -24,6 +24,47 @@
  */
 
 #include <core/object.h>
+#include <core/managedstatebit.h>
+#include <boost/bind.hpp>
+
+compiz::window::Object::Visitor::Visitor (const ObjectKey &, const compiz::window::Object::Ptr &o) :
+    mObject (o)
+{
+}
+
+compiz::window::Object::Visitor::~Visitor ()
+{
+}
+
+bool
+compiz::window::Object::Visitor::setGeometry (const Geometry &g)
+{
+    return mObject->setGeometry (g);
+}
+
+bool
+compiz::window::Object::Visitor::setStackPosition (const StackPosition &sp)
+{
+    return mObject->setStackPosition (sp);
+}
+
+bool
+compiz::window::Object::Visitor::setContainer (const boost::shared_ptr <compiz::window::Container> &c)
+{
+    return mObject->setContainer (c);
+}
+
+bool
+compiz::window::Object::Visitor::addState (const uint64_t &state)
+{
+    return mObject->addState (state);
+}
+
+bool
+compiz::window::Object::Visitor::removeState (const uint64_t &state)
+{
+    return mObject->removeState (state);
+}
 
 compiz::window::Object::Object (const compiz::window::ObjectIdentifier::Ptr &id) :
     mId (id)
@@ -96,6 +137,12 @@
     return mStackPosition;
 }
 
+const uint64_t &
+compiz::window::Object::state () const
+{
+    return mState;
+}
+
 const compiz::window::ObjectIdentifier::Ptr &
 compiz::window::Object::id () const
 {
@@ -124,6 +171,41 @@
 }
 
 bool
+compiz::window::Object::setContainer (const boost::shared_ptr <Container> &c)
+{
+    mContainer = c;
+}
+
+bool
+compiz::window::Object::addState (const uint64_t &aState)
+{
+    if ((aState & mState) == mState)
+	return false;
+    mState |= aState;
+    return true;
+}
+
+bool
+compiz::window::Object::removeState (const uint64_t &aState)
+{
+    if ((aState & mState) == 0)
+	return false;
+    mState |= ~aState;
+    return true;
+}
+
+compiz::window::ManagedStateBit compiz::window::Object::StateMapped;
+
+bool
+compiz::window::Object::setVisible (bool visible)
+{
+    if (visible)
+	return addState (StateMapped);
+
+    return removeState (StateMapped);
+}
+
+bool
 compiz::window::Object::setStackPosition (const StackPosition &sp)
 {
     mStackPosition = sp;
@@ -176,7 +258,15 @@
     return Object::setStackPosition (sp);
 }
 
-const boost::shared_ptr <compiz::window::Object> &
+bool
+compiz::window::SynchronousObject::setState (const uint64_t &sState)
+{
+    bool ret = Object::addState (sState & ~(state ()));
+    ret |= Object::removeState (~sState & state ());
+    return ret;
+}
+
+boost::shared_ptr <compiz::window::Object>
 compiz::window::ObjectIdentifier::operator() ()
 {
     if (mObj)
@@ -188,7 +278,7 @@
     }
 }
 
-const boost::shared_ptr <compiz::window::Object> &
+boost::shared_ptr <compiz::window::Object>
 compiz::window::ObjectIdentifier::operator() () const
 {
     if (mObj)

=== modified file 'src/server-read.cpp'
--- src/server-read.cpp	2012-01-19 18:25:05 +0000
+++ src/server-read.cpp	2012-01-19 18:25:06 +0000
@@ -55,6 +55,16 @@
 						     const compiz::window::AsynchronousContainer::Ptr &parent)
 {
     compiz::window::AsynchronousContainer::Ptr lastParent = boost::shared_static_cast <compiz::window::AsynchronousContainer> (child->container ());
-    lastParent->receiveRemoval (boost::shared_static_cast <compiz::window::Object> (child));
+
+    if (lastParent)
+	lastParent->receiveRemoval (boost::shared_static_cast <compiz::window::Object> (child));
     parent->receiveInsertion (boost::shared_static_cast <compiz::window::Object> (child));
 }
+
+void
+compiz::window::ReadServerConnection::receiveState (const AsynchronousObject::Ptr &ao,
+						    uint64_t			  addState,
+						    uint64_t			  removeState)
+{
+    ao->receiveState (addState, removeState);
+}

=== modified file 'src/server-write.cpp'
--- src/server-write.cpp	2012-01-19 18:25:05 +0000
+++ src/server-write.cpp	2012-01-19 18:25:06 +0000
@@ -55,5 +55,23 @@
     mServer->sendParent (id, pid);
 }
 
-
+void
+compiz::window::WriteServerConnection::sendCreateObject (const ObjectCreationRequest::Ptr &req)
+{
+    mServer->sendCreateObject (req);
+}
+
+void
+compiz::window::WriteServerConnection::sendDeleteObject (const ObjectIdentifier::Ptr &id)
+{
+    mServer->sendDeleteObject (id);
+}
+
+void
+compiz::window::WriteServerConnection::sendState (const ObjectIdentifier::Ptr &id,
+						  uint64_t		      addState,
+						  uint64_t		      removeState)
+{
+    mServer->sendState (id, addState, removeState);
+}
 

=== modified file 'src/server.cpp'
--- src/server.cpp	2012-01-19 18:25:05 +0000
+++ src/server.cpp	2012-01-19 18:25:06 +0000
@@ -40,8 +40,21 @@
     return mDefault;
 }
 
+void
+compiz::window::Server::SetDefault (Server::Ptr s)
+{
+    mDefault = s;
+}
+
 const compiz::window::Object::Ptr &
 compiz::window::Server::root ()
 {
     return mRoot;
 }
+
+void
+compiz::window::Server::setRoot (const compiz::window::Object::Ptr &root)
+{
+    assert (!mRoot);
+    mRoot = root;
+}

=== added file 'src/x11-container.cpp'
--- src/x11-container.cpp	1970-01-01 00:00:00 +0000
+++ src/x11-container.cpp	2012-01-19 18:25:06 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2010 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <core/container.h>
+#include <core/object.h>
+#include <core/x11-object.h>
+#include <boost/bind.hpp>
+#include <core/server-write.h>
+#include <core/windowgeometry.h>
+#include <core/stackposition.h>
+
+compiz::window::X11Container::X11Container (const ObjectIdentifier::Ptr         &id,
+					    const WriteServerConnection::Ptr    &writer,
+					    const compiz::window::Geometry      &g,
+					    const boost::shared_ptr <Container> &c) :
+    compiz::window::Object::Object (id, g, compiz::window::StackPosition (), c),
+    compiz::window::AsynchronousObject::AsynchronousObject (id, g, compiz::window::StackPosition (), c, writer),
+    compiz::window::AsynchronousContainer (id, g, compiz::window::StackPosition (), c, writer),
+    compiz::window::X11Object (id, writer, g, c)
+{
+}
+
+compiz::window::X11Container::~X11Container ()
+{
+}
+

=== added file 'src/x11-object.cpp'
--- src/x11-object.cpp	1970-01-01 00:00:00 +0000
+++ src/x11-object.cpp	2012-01-19 18:25:06 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright © 2010 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <core/x11-object.h>
+#include <core/x11-server.h>
+#include <core/server-write.h>
+#include <core/windowgeometry.h>
+#include <core/stackposition.h>
+#include <iostream>
+#include <cstdio>
+
+compiz::window::X11Object::X11Object (const ObjectIdentifier::Ptr         &id,
+				      const WriteServerConnection::Ptr    &writer,
+				      const compiz::window::Geometry      &g,
+				      const boost::shared_ptr <Container> &c) :
+    compiz::window::Object::Object (id, g, compiz::window::StackPosition (), c),
+    compiz::window::AsynchronousObject (id, g, compiz::window::StackPosition (), c, writer)
+{
+}
+
+compiz::window::X11Object::~X11Object ()
+{
+}
+
+compiz::window::X11ObjectIdentifier::X11ObjectIdentifier (Window id) :
+    compiz::window::ObjectIdentifier::ObjectIdentifier (),
+    mId (id)
+{
+}
+
+void
+compiz::window::X11ObjectIdentifier::print ()
+{
+    std::cout << "0x" << std::hex << mId;
+}
+
+compiz::window::X11ObjectIdentifier::~X11ObjectIdentifier ()
+{
+}
+
+compiz::window::ObjectIdentifier::ObjectType
+compiz::window::X11ObjectIdentifier::getType () const
+{
+    return X11;
+}
+
+bool
+compiz::window::X11ObjectIdentifier::compare (const ObjectIdentifier::Ptr &id) const
+{
+    const X11ObjectIdentifier::Ptr &xid = boost::shared_static_cast <X11ObjectIdentifier> (id);
+
+    return xid->mId == mId;
+}
+
+boost::shared_ptr <compiz::window::Object>
+compiz::window::X11ObjectIdentifier::lookup () const
+{
+    X11Server::Ptr server = boost::shared_static_cast <X11Server> (Server::Default ());
+    const boost::shared_ptr <const ObjectIdentifier> &ptr = boost::shared_static_cast <const ObjectIdentifier> (shared_from_this ());
+
+    return server->lookup (ptr);
+}

=== added file 'src/x11-server.cpp'
--- src/x11-server.cpp	1970-01-01 00:00:00 +0000
+++ src/x11-server.cpp	2012-01-19 18:25:06 +0000
@@ -0,0 +1,456 @@
+/*
+ * Copyright © 2010 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <core/x11-server.h>
+#include <core/x11-object.h>
+#include <privateeventsource.h>
+#include <boost/bind.hpp>
+#include <sys/poll.h>
+
+compiz::window::X11ObjectCreationRequest::X11ObjectCreationRequest (XSetWindowAttributes			   &attr,
+								    const compiz::window::Geometry		   &g,
+								    unsigned int				   cclass,
+								    unsigned int				   depth,
+								    const compiz::window::X11ObjectIdentifier::Ptr &parent,
+								    unsigned int				   attrValueMask,
+								    Visual					   *vis) :
+    mAttr (attr),
+    mGeometry (g),
+    mClass (cclass),
+    mDepth (depth),
+    mParent (parent),
+    mAttrValueMask (attrValueMask),
+    mVis (vis)
+{
+}
+
+compiz::window::X11ObjectCreationRequest::~X11ObjectCreationRequest ()
+{
+}
+
+XSetWindowAttributes &
+compiz::window::X11ObjectCreationRequest::attributes () const
+{
+    return mAttr;
+}
+
+const compiz::window::Geometry &
+compiz::window::X11ObjectCreationRequest::geometry () const
+{
+    return mGeometry;
+}
+
+const unsigned int &
+compiz::window::X11ObjectCreationRequest::cclass () const
+{
+    return mClass;
+}
+
+const unsigned int &
+compiz::window::X11ObjectCreationRequest::depth () const
+{
+    return mDepth;
+}
+
+const compiz::window::X11ObjectIdentifier::Ptr &
+compiz::window::X11ObjectCreationRequest::parent () const
+{
+    return mParent;
+}
+
+const unsigned int &
+compiz::window::X11ObjectCreationRequest::attrValueMask () const
+{
+    return mAttrValueMask;
+}
+
+Visual *
+compiz::window::X11ObjectCreationRequest::visual () const
+{
+    return mVis;
+}
+
+compiz::window::X11Server::X11Server () :
+    compiz::window::AsynchronousServer::AsynchronousServer (),
+    mDisplay (XOpenDisplay (NULL))
+{
+    if (!mDisplay)
+	throw std::exception ();
+
+    setupEventSource ();
+}
+
+compiz::window::X11Server::X11Server (const char		          *dname) :
+    compiz::window::AsynchronousServer::AsynchronousServer (),
+    mDisplay (XOpenDisplay (dname))
+{
+    if (!mDisplay)
+	throw std::exception ();
+
+    setupEventSource ();
+}
+
+compiz::window::X11Server::X11Server (Display			          *dpy) :
+    compiz::window::AsynchronousServer::AsynchronousServer (),
+    mDisplay (dpy)
+{
+    setupEventSource ();
+}
+
+void
+compiz::window::X11Server::setupEventSource ()
+{
+    CompEventSource *ev = CompEventSource::create (mDisplay,
+						   boost::bind (&X11Server::queueEvents, this));
+    Glib::RefPtr <Glib::Source> evrp = Glib::RefPtr <Glib::Source>::cast_static (Glib::RefPtr <CompEventSource> (ev));
+
+    setEventSource (evrp);
+}
+
+void
+compiz::window::X11Server::setRoot (Window root, const compiz::window::Geometry &g)
+{
+    compiz::window::X11ObjectIdentifier::Ptr rootId =
+	    compiz::window::X11ObjectIdentifier::Ptr (new compiz::window::X11ObjectIdentifier (root));
+    const compiz::window::ObjectIdentifier::Ptr    &genericRootId = boost::shared_static_cast <compiz::window::ObjectIdentifier> (rootId);
+    const compiz::window::Object::Ptr &rootObj = createObject (genericRootId, g, compiz::window::StackPosition (), compiz::window::Container::Ptr ());
+
+    Server::setRoot (rootObj);
+
+    XSetWindowAttributes xwa;
+
+    xwa.event_mask = StructureNotifyMask      |
+		     SubstructureNotifyMask   |
+		     SubstructureRedirectMask |
+		     ButtonPressMask |
+		     ButtonReleaseMask |
+		     KeyPressMask |
+		     KeyReleaseMask;
+
+    XChangeWindowAttributes (mDisplay, rootId->mId, CWEventMask, &xwa);
+    XSync (mDisplay, 0);
+}
+
+compiz::window::X11Server::~X11Server ()
+{
+    XCloseDisplay (mDisplay);
+}
+
+void
+compiz::window::populateXWindowChanges (const compiz::window::Geometry &g,
+					unsigned int                   mask,
+					XWindowChanges                 &xwc)
+{
+    if (mask & CWX)
+	xwc.x = g.x ();
+    if (mask & CWY)
+	xwc.y = g.y ();
+    if (mask & CWWidth)
+	xwc.width = g.width ();
+    if (mask & CWHeight)
+	xwc.height = g.height ();
+    if (mask & CWBorderWidth)
+	xwc.border_width = g.border ();
+}
+
+void
+compiz::window::populateXWindowChanges (const compiz::window::StackPosition &sp,
+					unsigned int                        mask,
+					XWindowChanges                      &xwc)
+{
+    if (mask & CWStackMode)
+	xwc.stack_mode = Above;
+    if (mask & CWSibling) {}
+	/* TODO:
+	xwc.sibling = sp */
+}
+
+void
+compiz::window::X11Server::sendGeometry (const ObjectIdentifier::Ptr    &id,
+					 const compiz::window::Geometry &g)
+{
+    Object::Ptr       o = (*id) ();
+    unsigned int      mask = g.changeMask (o->geometry ());
+    XWindowChanges    xwc;
+
+    populateXWindowChanges (g, mask, xwc);
+
+    XConfigureWindow (mDisplay, (boost::static_pointer_cast<X11ObjectIdentifier> (id))->mId, mask, &xwc);
+}
+
+void
+compiz::window::X11Server::sendStackPosition (const ObjectIdentifier::Ptr         &id,
+					      const compiz::window::StackPosition &sp)
+{
+    XWindowChanges xwc;
+    unsigned int   mask = CWStackMode | CWSibling;
+
+    populateXWindowChanges (sp, mask, xwc);
+
+    XConfigureWindow (mDisplay, (boost::static_pointer_cast<X11ObjectIdentifier> (id))->mId, mask, &xwc);
+}
+
+void
+compiz::window::X11Server::sendParent (const ObjectIdentifier::Ptr &child,
+				       const ObjectIdentifier::Ptr &parent)
+{
+    Window xchild = (boost::static_pointer_cast<X11ObjectIdentifier> (child))->mId;
+    Window xparent = (boost::static_pointer_cast<X11ObjectIdentifier> (parent))->mId;
+
+    XReparentWindow (mDisplay, xchild, xparent, 0, 0);
+}
+
+void
+compiz::window::X11Server::sendCreateObject (const boost::shared_ptr <compiz::window::ObjectCreationRequest> &req)
+{
+    const compiz::window::X11ObjectCreationRequest::Ptr &xobjcreq =
+	    boost::shared_static_cast <compiz::window::X11ObjectCreationRequest> (req);
+
+    XCreateWindow (mDisplay, xobjcreq->parent ()->mId, xobjcreq->geometry ().x (),
+		   xobjcreq->geometry ().y (), xobjcreq->geometry ().width (),
+		   xobjcreq->geometry ().height (), xobjcreq->geometry ().border (),
+		   xobjcreq->depth (),
+		   xobjcreq->cclass (),
+		   xobjcreq->visual (),
+		   xobjcreq->attrValueMask (),
+		   &xobjcreq->attributes ());
+}
+
+void
+compiz::window::X11Server::sendDeleteObject (const ObjectIdentifier::Ptr &id)
+{
+    const compiz::window::X11ObjectIdentifier::Ptr xid =
+	    boost::shared_static_cast <compiz::window::X11ObjectIdentifier> (id);
+
+    XDestroyWindow (mDisplay, xid->mId);
+}
+
+void
+compiz::window::X11Server::sendState (const ObjectIdentifier::Ptr &id,
+				      uint64_t			  addState,
+				      uint64_t                    removeState)
+{
+    const compiz::window::X11ObjectIdentifier::Ptr xid =
+	    boost::shared_static_cast <compiz::window::X11ObjectIdentifier> (id);
+
+    /* If something is being added and removed
+     * then clear both operations */
+    addState &= ~removeState;
+    removeState &= ~addState;
+
+    if (addState & compiz::window::Object::StateMapped)
+	XMapWindow (mDisplay, xid->mId);
+    else if (removeState & compiz::window::Object::StateMapped)
+	XUnmapWindow (mDisplay, xid->mId);
+
+    return;
+}
+
+void
+compiz::window::X11Server::dispatchRequests (unsigned int flags)
+{
+    if (flags & compiz::window::AsynchronousServer::BlockUntilCompletion)
+	XSync (mDisplay, flags & compiz::window::AsynchronousServer::DiscardGeneratedEvents ? true : false);
+    else
+	XFlush (mDisplay);
+}
+
+compiz::window::Object::Ptr compiz::window::X11Server::lookup (const boost::shared_ptr <const ObjectIdentifier> &id) const
+{
+    const X11ObjectIdentifier::ConstPtr &xid = boost::shared_static_cast <const X11ObjectIdentifier> (id);
+
+    const boost::unordered_map <Window, X11Object::Ptr>::const_iterator &it = mObjectTree.find (xid->mId);
+
+    if (it != mObjectTree.end ())
+	return mObjectTree.at (xid->mId);
+
+    return compiz::window::Object::Ptr ();
+}
+
+void
+compiz::window::X11Server::dispatchEvent (XEvent *event)
+{
+    /* FIXME: We're using boost::shared_polymorphic_cast here because
+     * Object is virtually inherited by AsynchronousObject and AsynchronousContainer
+     * as well as X11Object. Since there is no way that the compiler can know
+     * what the offset of X11Object is going to be here, we need to use a runtime
+     * cast */
+    switch (event->type)
+    {
+	case ConfigureNotify:
+	{
+	    compiz::window::X11ObjectIdentifier::Ptr id =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xconfigure.window));
+
+	    const compiz::window::X11Object::Ptr &xo = boost::shared_polymorphic_cast <compiz::window::X11Object> ((*id) ());
+	    compiz::window::Geometry			  g (event->xconfigure.x,
+							     event->xconfigure.y,
+							     event->xconfigure.width,
+							     event->xconfigure.height,
+							     event->xconfigure.border_width);
+	    compiz::window::StackPosition		  sp;
+
+	    mReadConnection->receiveGeometry (xo, g);
+	    mReadConnection->receiveStackPosition (xo, sp);
+	}
+	    break;
+	case ReparentNotify:
+	{
+	    compiz::window::X11ObjectIdentifier::Ptr childId =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xreparent.window));
+	    compiz::window::X11ObjectIdentifier::Ptr parentId =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xreparent.parent));
+
+	    compiz::window::X11Object::Ptr child = boost::shared_polymorphic_cast <compiz::window::X11Object> ((*childId) ());
+	    compiz::window::X11Container::Ptr parent = boost::shared_polymorphic_cast <compiz::window::X11Container> ((*parentId) ());
+
+	    mReadConnection->receiveParent (child, parent);
+	}
+	    break;
+	case CreateNotify:
+	{
+	    compiz::window::X11ObjectIdentifier::Ptr childId =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xcreatewindow.window));
+	    compiz::window::X11ObjectIdentifier::Ptr parentId =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xcreatewindow.parent));
+
+	    /* Need to create the child first */
+	    compiz::window::X11Container::Ptr parent = boost::shared_polymorphic_cast <compiz::window::X11Container> ((*parentId) ());
+	    compiz::window::X11Object::Ptr child =
+		    boost::shared_polymorphic_cast <compiz::window::X11Object> (createObject (boost::shared_static_cast <compiz::window::ObjectIdentifier> (childId),
+											      compiz::window::Geometry (event->xcreatewindow.x,
+															event->xcreatewindow.y,
+															event->xcreatewindow.width,
+															event->xcreatewindow.height,
+															event->xcreatewindow.border_width),
+											      compiz::window::StackPosition (),
+											      parent));
+
+	    mReadConnection->receiveParent (child, parent);
+	}
+	    break;
+	case DestroyNotify:
+	{
+	    compiz::window::X11ObjectIdentifier::Ptr windowId =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xdestroywindow.window));
+	    compiz::window::X11Object::Ptr    window = boost::shared_polymorphic_cast <compiz::window::X11Object> ((*windowId) ());
+	    compiz::window::X11Container::Ptr newParent = compiz::window::X11Container::Ptr ();
+
+	    mReadConnection->receiveParent (window, newParent);
+	}
+	    break;
+	case MapNotify:
+	{
+	    compiz::window::X11ObjectIdentifier::Ptr windowId =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xdestroywindow.window));
+	    compiz::window::X11Object::Ptr    window = boost::shared_polymorphic_cast <compiz::window::X11Object> ((*windowId) ());
+
+	    mReadConnection->receiveState (window, compiz::window::Object::StateMapped, 0);
+	}
+	    break;
+	case UnmapNotify:
+	{
+	    compiz::window::X11ObjectIdentifier::Ptr windowId =
+		    compiz::window::X11ObjectIdentifier::Ptr (
+			new compiz::window::X11ObjectIdentifier (event->xdestroywindow.window));
+	    compiz::window::X11Object::Ptr    window = boost::shared_polymorphic_cast <compiz::window::X11Object> ((*windowId) ());
+
+	    mReadConnection->receiveState (window, 0, compiz::window::Object::StateMapped);
+	}
+	    break;
+	default:
+	    break;
+
+    }
+}
+
+void
+compiz::window::X11Server::queueEvents ()
+{
+    std::vector <XEvent> events;
+
+    while (XPending (mDisplay))
+    {
+	XEvent event, peekEvent;
+	XNextEvent (mDisplay, &event);
+
+	/* Skip to the last MotionNotify
+	 * event in this sequence */
+	if (event.type == MotionNotify)
+	{
+	    while (XPending (mDisplay))
+	    {
+		XPeekEvent (mDisplay, &peekEvent);
+
+		if (peekEvent.type != MotionNotify)
+		    break;
+
+		XNextEvent (mDisplay, &event);
+	    }
+	}
+
+	events.push_back (event);
+    }
+
+    for (std::vector <XEvent>::iterator it = events.begin ();
+	 it != events.end ();
+	 it++)
+	dispatchEvent (&(*it));
+}
+
+void
+compiz::window::X11Server::addObjectToTree (const std::pair <compiz::window::X11ObjectIdentifier::Ptr,
+							     compiz::window::X11Object::Ptr> &keyValue)
+{
+    if (mObjectTree.find (keyValue.first->mId) != mObjectTree.end ())
+	throw std::exception ();
+
+    XSetWindowAttributes xwa;
+
+    xwa.event_mask = SubstructureNotifyMask   |
+		     ButtonPressMask |
+		     ButtonReleaseMask |
+		     KeyPressMask |
+		     KeyReleaseMask;
+
+    XSynchronize (mDisplay, true);
+    XChangeWindowAttributes (mDisplay, keyValue.first->mId, CWEventMask, &xwa);
+
+    mObjectTree[keyValue.first->mId] = keyValue.second;
+}
+
+void
+compiz::window::X11Server::removeKeyFromTree (const ObjectIdentifier::Ptr &id)
+{
+    const compiz::window::X11ObjectIdentifier::Ptr &xid = boost::shared_static_cast <compiz::window::X11ObjectIdentifier> (id);
+    mObjectTree.erase (xid->mId);
+}

=== added directory 'tests/standalone'
=== added file 'tests/standalone/CMakeLists.txt'
--- tests/standalone/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/standalone/CMakeLists.txt	2012-01-19 18:25:06 +0000
@@ -0,0 +1,1 @@
+add_subdirectory (objects)

=== added directory 'tests/standalone/objects'
=== added file 'tests/standalone/objects/CMakeLists.txt'
--- tests/standalone/objects/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/standalone/objects/CMakeLists.txt	2012-01-19 18:25:06 +0000
@@ -0,0 +1,23 @@
+find_package (Boost REQUIRED)
+
+pkg_check_modules (COMPIZ_OBJECTS_STANDALONE_TEST glibmm-2.4 x11)
+
+if (COMPIZ_OBJECTS_STANDALONE_TEST_FOUND)
+
+	set (COMPIZ_OBJECTS_STANDALONE_TEST_BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+	set (COMPIZ_OBJECTS_STANDALONE_TEST_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+	include_directories (${COMPIZ_OBJECTS_STANDALONE_TEST_INCLUDE_DIRS}
+			     ${CMAKE_CURRENT_SOURCE_DIR}
+			     ${compiz_SOURCE_DIR}/src
+			     ${compiz_SOURCE_DIR}/include
+			     ${Boost_INCLUDE_DIRS})
+	link_directories (${COMPIZ_OBJECT_STANDALONE_TEST_LINK_DIRS}
+			  ${Boost_LINK_DIRS})
+	add_library (commandparser STATIC ${CMAKE_CURRENT_SOURCE_DIR}/command-parser.cpp)
+
+	target_link_libraries (commandparser ${COMPIZ_OBJECTS_STANDALONE_TEST_LIBRARIES} ${Boost_LIBRARIES})
+
+	add_subdirectory (x11)
+
+endif (COMPIZ_OBJECTS_STANDALONE_TEST_FOUND)

=== added file 'tests/standalone/objects/command-parser.cpp'
--- tests/standalone/objects/command-parser.cpp	1970-01-01 00:00:00 +0000
+++ tests/standalone/objects/command-parser.cpp	2012-01-19 18:25:06 +0000
@@ -0,0 +1,449 @@
+/*
+ * Copyright © 2010 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <command-parser.h>
+
+Glib::RefPtr <StdinSource>
+StdinSource::create (const Glib::RefPtr <Glib::MainLoop> &ml)
+{
+    return Glib::RefPtr <StdinSource> (new StdinSource (ml));
+}
+
+StdinSource::StdinSource (const Glib::RefPtr <Glib::MainLoop> &ml) :
+    Glib::IOSource (STDIN_FILENO, Glib::IO_IN | Glib::IO_HUP),
+    mMainLoop (ml)
+{
+    connect (sigc::mem_fun <Glib::IOCondition, bool, StdinSource> (this, &StdinSource::callback));
+    attach (Glib::MainContext::get_default ());
+}
+
+Parser::Parser (const std::string &token, std::string::const_iterator begin, std::string::const_iterator end) :
+    mBegin (begin),
+    mEnd (end),
+    mAdvanceLength (token.size ())
+{
+}
+
+Parser::Parser (unsigned int n, std::string::const_iterator begin, std::string::const_iterator end) :
+    mBegin (begin),
+    mEnd (end),
+    mAdvanceLength (n)
+{
+}
+
+Parser::~Parser ()
+{
+}
+
+void
+Parser::advance ()
+{
+    std::advance (mBegin, mAdvanceLength);
+}
+
+void
+Parser::advance (unsigned int n)
+{
+    std::advance (mBegin, n);
+}
+
+void
+Parser::parse (boost::spirit::unused_type r, boost::spirit::unused_type, bool &)
+{
+    r = parseStringIterators (mBegin, mEnd);
+}
+
+GeometryParser::GeometryParser (std::string::const_iterator begin, std::string::const_iterator end, const compiz::window::Geometry &old) :
+    Parser ("geometry", begin, end),
+    mGeometry (old)
+{
+}
+
+GeometryParser::~GeometryParser ()
+{
+}
+
+bool
+GeometryParser::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    advance ();
+    int x, y;
+    unsigned int width, height, border;
+
+    using boost::spirit::qi::uint_;
+    using boost::spirit::qi::int_;
+    using boost::spirit::qi::_1;
+    using boost::spirit::qi::phrase_parse;
+    using boost::spirit::ascii::space;
+    using boost::phoenix::ref;
+
+    advance (1);
+    if (boost::spirit::qi::parse (mBegin, mEnd,
+				  '(' >> int_[ref (x) = _1] >> ", " >>
+				  int_[ref (y) = _1] >> ", " >>
+				  uint_[ref (width) = _1] >> ", " >>
+				  uint_[ref (height) = _1] >> ", " >>
+				  uint_[ref (border) = _1] >> ')'))
+    {
+	mGeometry.set (x, y, width, height, border);
+	return true;
+    }
+
+    std::cout << "geometry (" << mGeometry.x () << ", "
+			      << mGeometry.y () << ", "
+			      << mGeometry.width () << ", "
+			      << mGeometry.height () << ", "
+			      << mGeometry.border () << ")" << std::endl;
+    return false;
+}
+
+ObjectsParser::ObjectsParser (std::string::const_iterator begin, std::string::const_iterator end, const compiz::window::Container::Children &old) :
+    Parser ("objects", begin, end),
+    mChildren (old)
+{
+}
+
+ObjectsParser::~ObjectsParser ()
+{
+}
+
+bool
+ObjectsParser::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    advance ();
+    std::vector <unsigned int> v (0);
+
+    using boost::spirit::qi::hex;
+    using boost::spirit::qi::_1;
+    using boost::spirit::qi::phrase_parse;
+    using boost::spirit::ascii::space;
+    using boost::phoenix::ref;
+    using boost::phoenix::push_back;
+
+    advance (1);
+    if (boost::spirit::qi::parse (mBegin, mEnd,
+				  "(0x" >> hex[push_back (ref (v), _1)]
+				  >> *(",0x" >> hex[push_back (ref (v), _1)]) >> ")"
+				  ))
+    {
+	mChildren.clear ();
+	for (std::vector <unsigned int>::iterator it = v.begin ();
+	     it != v.end ();
+	     it++)
+	{
+	    compiz::window::X11ObjectIdentifier::Ptr xid = compiz::window::X11ObjectIdentifier::Ptr (new compiz::window::X11ObjectIdentifier ((*it)));
+	    const compiz::window::Object::Ptr &obj = (*xid) ();
+	    mChildren.push_back (obj);
+	}
+	return true;
+    }
+
+    std::cout << "objects -" << std::endl;
+    for (compiz::window::Container::Children::iterator it = mChildren.begin ();
+	 it != mChildren.end ();
+	 it++)
+    {
+	compiz::window::Object::Ptr obj = (*it);
+	const compiz::window::ObjectIdentifier::Ptr &id = obj->id ();
+	const compiz::window::X11ObjectIdentifier::Ptr xid = boost::shared_static_cast <compiz::window::X11ObjectIdentifier> (id);
+
+	std::cout << " - id: ";
+	xid->print ();
+	std::cout << std::endl;
+    }
+
+    mChildren.clear ();
+
+    return false;
+}
+
+CreateParser::CreateParser (std::string::const_iterator begin, std::string::const_iterator end) :
+    Parser ("create", begin, end)
+{
+}
+
+CreateParser::~CreateParser ()
+{
+}
+
+bool
+CreateParser::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    advance ();
+    bool input;
+    bool override = false;
+    unsigned int parent;
+    int x, y;
+    unsigned int width, height, border;
+
+    using boost::spirit::qi::hex;
+    using boost::spirit::qi::uint_;
+    using boost::spirit::qi::int_;
+    using boost::spirit::qi::bool_;
+    using boost::spirit::qi::_1;
+    using boost::spirit::qi::phrase_parse;
+    using boost::spirit::ascii::space;
+    using boost::phoenix::ref;
+    using boost::phoenix::push_back;
+
+    advance (1);
+    if (boost::spirit::qi::parse (mBegin, mEnd,
+				  "(0x" >> hex[ref (parent) = _1]
+				  >> ", (" >> int_[ref (x) = _1] >> ", " >>
+					     int_[ref (y) = _1] >> ", " >>
+					     uint_[ref (width) = _1] >> ", " >>
+					     uint_[ref (height) = _1] >> ", " >>
+					     uint_[ref (border) = _1] >> "), " >>
+				  bool_[ref (input) = _1] >> ", " >>
+				  bool_[ref (override) = _1] >> ")"))
+    {
+	XSetWindowAttributes childAttr;
+	unsigned int mask = 0;
+	compiz::window::X11ObjectIdentifier::Ptr parentId = compiz::window::X11ObjectIdentifier::Ptr (new compiz::window::X11ObjectIdentifier (parent));
+
+	if (override)
+	{
+	    childAttr.override_redirect = 1;
+	    mask |= CWOverrideRedirect;
+	}
+
+
+	mXcreq = compiz::window::X11ObjectCreationRequest::Ptr (new compiz::window::X11ObjectCreationRequest (childAttr, compiz::window::Geometry (x, y, width, height, border),
+													      input ? InputOnly : InputOutput, CopyFromParent,
+													      parentId,
+													      mask, CopyFromParent));
+
+	return true;
+    }
+    else
+	std::cout << "USAGE: create (parentId, (x,y,width,height,border), input_only, override)" << std::endl;
+
+
+    return false;
+}
+
+StackPositionParser::StackPositionParser (std::string::const_iterator begin, std::string::const_iterator end, const compiz::window::StackPosition &old) :
+    Parser ("stackposition", begin, end),
+    mStackPosition (old)
+{
+}
+
+StackPositionParser::~StackPositionParser ()
+{
+}
+
+bool
+StackPositionParser::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    return false;
+}
+
+PropertyParser::PropertyParser (std::string::const_iterator begin, std::string::const_iterator end, uint64_t old) :
+    Parser ("property", begin, end),
+    mProperties (old)
+{
+}
+
+PropertyParser::~PropertyParser ()
+{
+}
+
+bool
+PropertyParser::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    return false;
+}
+
+XidParser::XidParser (std::string::const_iterator begin, std::string::const_iterator end) :
+    Parser (2, begin, end)
+{
+}
+
+XidParser::~XidParser ()
+{
+}
+
+bool
+XidParser::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    advance ();
+    using boost::spirit::qi::hex;
+    using boost::spirit::qi::_1;
+    using boost::spirit::qi::phrase_parse;
+    using boost::spirit::ascii::space;
+    using boost::phoenix::ref;
+    unsigned int uxid = 0;
+
+    if (boost::spirit::qi::parse (mBegin, mEnd, hex[ref(uxid) = _1], space))
+    {
+	compiz::window::X11ObjectIdentifier::Ptr xid = compiz::window::X11ObjectIdentifier::Ptr (new compiz::window::X11ObjectIdentifier (uxid));
+	compiz::window::Object::Ptr o = (*xid) ();
+	const compiz::window::X11Container::Ptr &xc = boost::shared_dynamic_cast <compiz::window::X11Container> (o);
+	if (!o)
+	    return false;
+	else
+	{
+	    std::advance (mBegin, 1);
+	    GeometryParser gp (mBegin, mEnd, o->geometry ());
+	    StackPositionParser sp (mBegin, mEnd, o->stackPosition ());
+	    PropertyParser pp (mBegin, mEnd, o->state ());
+	    ObjectsParser op (mBegin, mEnd, xc ? xc->children () : compiz::window::Container::Children (0));
+	    if (boost::spirit::qi::parse (mBegin, mEnd,
+					  boost::spirit::qi::lit ("geometry")[boost::bind (&GeometryParser::parse, &gp, _1, _2, _3)]))
+	    {
+		/* Send new geometry */
+		const compiz::window::X11Server::Ptr &serverp = boost::shared_static_cast <compiz::window::X11Server> (compiz::window::Server::Default ());
+		compiz::window::WriteServerConnection::Ptr conn = serverp->connect ();
+		conn->sendGeometry (o->id (), gp.geometry ());
+		serverp->flush (0);
+		return true;
+	    }
+	    else if (boost::spirit::qi::parse (mBegin, mEnd,
+					       boost::spirit::qi::lit ("stackposition")[boost::bind (&StackPositionParser::parse, &sp, _1, _2, _3)]))
+	    {
+		return true;
+	    }
+	    else if (boost::spirit::qi::parse (mBegin, mEnd,
+					       boost::spirit::qi::lit ("properties")[boost::bind (&PropertyParser::parse, &pp, 1, _2, _3)]))
+	    {
+		return true;
+	    }
+	    else if (boost::spirit::qi::parse (mBegin, mEnd,
+					       boost::spirit::qi::lit ("objects")[boost::bind (&ObjectsParser::parse, &op, 1, _2, _3)]))
+	    {
+		/* Send removal of any children from parents and send insertion
+		 * to this parent */
+		if (xc)
+		{
+		    for (compiz::window::Container::Children::const_iterator it = op.children ().begin ();
+			 it != op.children ().end ();
+			 it++)
+		    {
+			const compiz::window::Object::Ptr &oc = (*it);
+			const compiz::window::Container::Ptr &pc = oc->container ();
+			const compiz::window::AsynchronousContainer::Ptr &apc = boost::shared_dynamic_cast <compiz::window::AsynchronousContainer> (pc);
+
+			if (apc)
+			{
+			    apc->sendRemoval (oc);
+			    xc->sendInsertion (oc);
+			}
+		    }
+		}
+		return true;
+	    }
+	    else
+		return false;
+	}
+    }
+
+    return false;
+}
+
+ListMatcher::ListMatcher (std::string::const_iterator begin, std::string::const_iterator end) :
+    Parser::Parser ("list", begin, end)
+{
+}
+
+ListMatcher::~ListMatcher ()
+{
+}
+
+bool
+ListMatcher::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    /* on "list" just print out the toplevel trees
+     * like the root object id */
+
+    const compiz::window::X11Object::Ptr &rt = boost::shared_polymorphic_cast <compiz::window::X11Object> (compiz::window::Server::Default ()->root ());
+    const compiz::window::ObjectIdentifier::Ptr &id = rt->id ();
+    const compiz::window::X11ObjectIdentifier::Ptr &xid = boost::shared_static_cast <compiz::window::X11ObjectIdentifier> (id);
+
+    std::cout << "Root Object: ";
+    xid->print ();
+    std::cout << std::endl;
+    return false;
+}
+
+ObjectMatcher::ObjectMatcher (std::string::const_iterator begin, std::string::const_iterator end) :
+    Parser::Parser ("object", begin, end)
+{
+}
+
+ObjectMatcher::~ObjectMatcher ()
+{
+}
+
+bool
+ObjectMatcher::parseStringIterators (std::string::const_iterator begin, std::string::const_iterator end)
+{
+    advance ();
+    advance (1);
+    XidParser xp (mBegin, mEnd);
+
+    return boost::spirit::qi::parse (mBegin, mEnd,
+				     boost::spirit::qi::lit ("0x") [boost::bind (&XidParser::parse, &xp, _1, _2, _3)]);
+}
+
+bool
+StdinSource::callback (Glib::IOCondition cond)
+{
+    if (cond & Glib::IO_IN)
+    {
+	std::string str;
+	std::getline (std::cin, str);
+	std::string::const_iterator b = str.begin ();
+	std::string::const_iterator e = str.end ();
+	ObjectMatcher op (b, e);
+	ListMatcher   lp (b, e);
+	CreateParser  cp (b, e);
+	if (boost::spirit::qi::parse (b, e, boost::spirit::qi::lit ("object")[boost::bind (&ObjectMatcher::parse, &op, _1, _2, _3)]))
+	{
+	}
+	else if (boost::spirit::qi::parse (b, e, boost::spirit::qi::lit ("list")[boost::bind (&ListMatcher::parse, &lp, _1, _2, _3)]))
+	{
+	}
+	else if (boost::spirit::qi::parse (b, e, boost::spirit::qi::lit ("create")[boost::bind (&CreateParser::parse, &cp, _1, _2, _3)]))
+	{
+	    compiz::window::WriteServerConnection::Ptr w = boost::shared_static_cast <compiz::window::AsynchronousServer> (compiz::window::Server::Default ())->connect ();
+
+	    if (cp.xcreq ())
+		w->sendCreateObject (cp.xcreq ());
+	}
+	else if (boost::spirit::qi::parse (b, e, boost::spirit::qi::lit ("quit")))
+	{
+	    mMainLoop->quit ();
+	    return false;
+	}
+
+	std::cout << ">> ";
+    }
+
+    return true;
+}
+
+StdinSource::~StdinSource ()
+{
+}

=== added file 'tests/standalone/objects/command-parser.h'
--- tests/standalone/objects/command-parser.h	1970-01-01 00:00:00 +0000
+++ tests/standalone/objects/command-parser.h	2012-01-19 18:25:06 +0000
@@ -0,0 +1,190 @@
+/*
+ * Copyright © 2010 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <core/x11-server.h>
+#include <core/x11-object.h>
+#include <X11/Xlib.h>
+#include <boost/shared_ptr.hpp>
+#include <cairo/cairo.h>
+#include <cairo/cairo-xlib.h>
+#include <core/object.h>
+#include <core/container.h>
+#include <core/server-write.h>
+#include <sys/poll.h>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_object.hpp>
+#include <boost/spirit/include/phoenix_stl.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/spirit/include/qi_uint.hpp>
+
+#include <boost/bind.hpp>
+
+class StdinSource :
+    public Glib::IOSource
+{
+    public:
+
+	static Glib::RefPtr <StdinSource> create (const Glib::RefPtr <Glib::MainLoop> &ml);
+	~StdinSource ();
+
+    private:
+
+	bool callback (Glib::IOCondition);
+
+	StdinSource (const Glib::RefPtr <Glib::MainLoop> &ml);
+	Glib::RefPtr <Glib::MainLoop> mMainLoop;
+};
+
+class Parser
+{
+    public:
+	virtual ~Parser ();
+	void parse (boost::spirit::unused_type, boost::spirit::unused_type, bool &);
+    protected:
+	virtual bool parseStringIterators (std::string::const_iterator begin,
+					   std::string::const_iterator end) = 0;
+
+	Parser (const std::string &token, std::string::const_iterator begin, std::string::const_iterator end);
+	Parser (unsigned int, std::string::const_iterator begin, std::string::const_iterator end);
+
+	void advance ();
+	void advance (unsigned int);
+
+	mutable std::string::const_iterator mBegin;
+	mutable std::string::const_iterator mEnd;
+    private:
+	unsigned int mAdvanceLength;
+};
+
+class ObjectMatcher :
+    public Parser
+{
+    public:
+	ObjectMatcher (std::string::const_iterator begin, std::string::const_iterator end);
+	~ObjectMatcher ();
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+
+    private:
+
+	mutable compiz::window::Object::Ptr mObj;
+};
+
+class ListMatcher :
+    public Parser
+{
+    public:
+	ListMatcher (std::string::const_iterator begin, std::string::const_iterator end);
+	~ListMatcher ();
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+};
+
+class XidParser :
+    public Parser
+{
+    public:
+	XidParser (std::string::const_iterator begin, std::string::const_iterator end);
+	~XidParser ();
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+    private:
+	mutable compiz::window::X11ObjectIdentifier::Ptr mXid;
+};
+
+class GeometryParser :
+    public Parser
+{
+    public:
+	GeometryParser (std::string::const_iterator begin, std::string::const_iterator end, const compiz::window::Geometry &old);
+	~GeometryParser ();
+	const compiz::window::Geometry & geometry () { return mGeometry; };
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+    private:
+	compiz::window::Geometry mGeometry;
+};
+
+class ObjectsParser :
+    public Parser
+{
+    public:
+	ObjectsParser (std::string::const_iterator begin, std::string::const_iterator end, const compiz::window::Container::Children &old);
+	~ObjectsParser ();
+	const compiz::window::Container::Children & children () { return mChildren; };
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+    private:
+	compiz::window::Container::Children mChildren;
+};
+
+class CreateParser :
+    public Parser
+{
+    public:
+	CreateParser (std::string::const_iterator begin, std::string::const_iterator end);
+	~CreateParser ();
+	const compiz::window::X11ObjectCreationRequest::Ptr & xcreq () { return mXcreq; }
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+    private:
+	compiz::window::X11ObjectCreationRequest::Ptr mXcreq;
+};
+
+class StackPositionParser :
+    public Parser
+{
+    public:
+	StackPositionParser (std::string::const_iterator begin, std::string::const_iterator end, const compiz::window::StackPosition &old);
+	~StackPositionParser ();
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+    private:
+	mutable compiz::window::StackPosition mStackPosition;
+};
+
+class PropertyParser :
+    public Parser
+{
+    public:
+	PropertyParser (std::string::const_iterator begin, std::string::const_iterator end, uint64_t old);
+	~PropertyParser ();
+    protected:
+	bool parseStringIterators (std::string::const_iterator begin,
+				   std::string::const_iterator end);
+    private:
+	mutable uint64_t mProperties;
+};
+

=== added directory 'tests/standalone/objects/mockwire'
=== added directory 'tests/standalone/objects/x11'
=== added file 'tests/standalone/objects/x11/CMakeLists.txt'
--- tests/standalone/objects/x11/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/standalone/objects/x11/CMakeLists.txt	2012-01-19 18:25:06 +0000
@@ -0,0 +1,43 @@
+pkg_check_modules (X11_OBJECT_TREE_STANDALONE REQUIRED x11 glibmm-2.4 cairo cairo-xlib)
+
+if (X11_OBJECT_TREE_STANDALONE_FOUND)
+
+    include_directories (${X11_OBJECT_TREE_STANDALONE_INCLUDE_DIRS}
+			 ${COMPIZ_OBJECTS_STANDALONE_TEST_BASE_DIR}
+			 ${compiz_SOURCE_DIR}/src/
+			 ${compiz_SOURCE_DIR}/include/
+			 # Module specific include dirs
+
+			 ${compiz_SOURCE_DIR}/src/timer/include
+			 ${compiz_SOURCE_DIR}/src/timer/src)
+
+    link_directories (${X11_OBJECT_TREE_STANDALONE_LIBRARY_DIRS}
+		      ${COMPIZ_OBJECTS_STANDALONE_TEST_BINARY_DIR})
+
+    add_executable (compiz-x11-object-tree-standalone
+		    compiz-x11-object-tree-standalone.cpp
+		    ${compiz_SOURCE_DIR}/src/x11-server.cpp
+		    ${compiz_SOURCE_DIR}/src/asynchronous-server.cpp
+		    ${compiz_SOURCE_DIR}/src/server.cpp
+		    ${compiz_SOURCE_DIR}/src/server-read.cpp
+		    ${compiz_SOURCE_DIR}/src/server-write.cpp
+		    ${compiz_SOURCE_DIR}/src/object.cpp
+		    ${compiz_SOURCE_DIR}/src/container.cpp
+		    ${compiz_SOURCE_DIR}/src/asynchronous-object.cpp
+		    ${compiz_SOURCE_DIR}/src/asynchronous-container.cpp
+		    ${compiz_SOURCE_DIR}/src/x11-object.cpp
+		    ${compiz_SOURCE_DIR}/src/x11-container.cpp
+		    ${compiz_SOURCE_DIR}/src/windowgeometry.cpp
+		    ${compiz_SOURCE_DIR}/src/stackposition.cpp
+		    ${compiz_SOURCE_DIR}/src/stack.cpp
+		    ${compiz_SOURCE_DIR}/src/asynchronous-stack.cpp
+		    ${compiz_SOURCE_DIR}/src/rect.cpp
+		    ${compiz_SOURCE_DIR}/src/eventsource.cpp
+                    ${compiz_SOURCE_DIR}/src/point.cpp
+                    ${compiz_SOURCE_DIR}/src/managedstatebit.cpp)
+
+    target_link_libraries (compiz-x11-object-tree-standalone
+			   commandparser
+			   ${X11_OBJECT_TREE_STANDALONE_LIBRARIES})
+
+endif (X11_OBJECT_TREE_STANDALONE_FOUND)

=== added file 'tests/standalone/objects/x11/compiz-x11-object-tree-standalone.cpp'
--- tests/standalone/objects/x11/compiz-x11-object-tree-standalone.cpp	1970-01-01 00:00:00 +0000
+++ tests/standalone/objects/x11/compiz-x11-object-tree-standalone.cpp	2012-01-19 18:25:06 +0000
@@ -0,0 +1,338 @@
+/*
+ * Copyright © 2010 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Canonical Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Canonical Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * CANONICAL, LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL CANONICAL, LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include <core/x11-server.h>
+#include <core/x11-object.h>
+#include <X11/Xlib.h>
+#include <boost/shared_ptr.hpp>
+#include <cairo/cairo.h>
+#include <cairo/cairo-xlib.h>
+#include <core/object.h>
+#include <core/container.h>
+#include <core/server-write.h>
+#include <command-parser.h>
+
+#include <boost/bind.hpp>
+
+class MockX11Server :
+    public compiz::window::X11Server
+{
+    public:
+
+	typedef boost::shared_ptr <MockX11Server> Ptr;
+
+	void setRoot (Window root, const compiz::window::Geometry &);
+
+	compiz::window::Object::Ptr
+	createObject (const compiz::window::ObjectIdentifier::Ptr &id,
+		      const compiz::window::Geometry		  &g,
+		      const compiz::window::StackPosition         &sp,
+		      const compiz::window::Container::Ptr        &c);
+
+	void
+	removeObject (const compiz::window::ObjectIdentifier::Ptr &id);
+
+	MockX11Server (Display *, Glib::RefPtr <Glib::MainLoop> &ml);
+	~MockX11Server ();
+};
+
+class MockX11Object :
+    public compiz::window::X11Container
+{
+    public:
+
+	typedef boost::shared_ptr <MockX11Object> Ptr;
+
+	virtual ~MockX11Object ();
+
+    protected:
+
+	void onReceiveGeometry (const compiz::window::Geometry &g);
+	void onReceiveStackPosition (const compiz::window::StackPosition &sp);
+	void onReceiveInsertion (const compiz::window::Object::Ptr &o);
+	void onReceiveRemoval (const compiz::window::Object::Ptr &o);
+	void onReceiveDeletion ();
+	void onReceiveAddState (uint64_t state);
+	void onReceiveRemoveState (uint64_t state);
+
+	void onSendGeometry (const compiz::window::Geometry &g);
+	void onSendStackPosition (const compiz::window::StackPosition &sp);
+	void onSendInsertion (const compiz::window::Object::Ptr &o);
+	void onSendRemoval (const compiz::window::Object::Ptr &o);
+	void onSendDeletion ();
+	void onSendAddState (uint64_t state);
+	void onSendRemoveState (uint64_t state);
+
+    private:
+
+	MockX11Object (const compiz::window::ObjectIdentifier::Ptr			&,
+		       const boost::shared_ptr <compiz::window::WriteServerConnection>  &,
+		       const compiz::window::Geometry					&,
+		       const boost::shared_ptr <compiz::window::Container>		&);
+
+	friend class MockX11Server;
+};
+
+MockX11Object::MockX11Object (const compiz::window::ObjectIdentifier::Ptr		      &id,
+			      const boost::shared_ptr <compiz::window::WriteServerConnection> &write,
+			      const compiz::window::Geometry				      &g,
+			      const boost::shared_ptr <compiz::window::Container>	      &c) :
+    Object (id, g),
+    AsynchronousObject (id, g, write),
+    X11Container (id, write, g, c)
+{
+}
+
+void
+MockX11Object::onReceiveGeometry (const compiz::window::Geometry &g)
+{
+    std::cout << "DEBUG: " << __func__ << " g: " << g.x () << " "
+	      << g.y () << " "
+	      << g.width () << " "
+	      << g.height () << " "
+	      << g.border () << std::endl;
+}
+
+void
+MockX11Object::onReceiveStackPosition (const compiz::window::StackPosition &sp)
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onReceiveInsertion (const compiz::window::Object::Ptr &o)
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onReceiveRemoval (const compiz::window::Object::Ptr &o)
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onReceiveDeletion ()
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onReceiveAddState (uint64_t state)
+{
+    std::cout << "DEBUG: " << __func__ << std::hex << state << std::dec << std::endl;
+}
+
+void
+MockX11Object::onReceiveRemoveState (uint64_t state)
+{
+    std::cout << "DEBUG: " << __func__ << std::hex << state << std::dec << std::endl;
+}
+
+void
+MockX11Object::onSendGeometry (const compiz::window::Geometry &g)
+{
+    std::cout << "DEBUG: " << __func__ << " g: " << g.x () << " "
+	      << g.y () << " "
+	      << g.width () << " "
+	      << g.height () << " "
+	      << g.border () << std::endl;
+}
+
+void
+MockX11Object::onSendStackPosition (const compiz::window::StackPosition &sp)
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onSendInsertion (const compiz::window::Object::Ptr &o)
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onSendRemoval (const compiz::window::Object::Ptr &o)
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onSendDeletion ()
+{
+    std::cout << "DEBUG: " << __func__ << std::endl;
+}
+
+void
+MockX11Object::onSendAddState (uint64_t state)
+{
+    std::cout << "DEBUG: " << __func__ << std::hex << state << std::dec << std::endl;
+}
+
+void
+MockX11Object::onSendRemoveState (uint64_t state)
+{
+    std::cout << "DEBUG: " << __func__ << std::hex << state << std::dec << std::endl;
+}
+
+MockX11Object::~MockX11Object ()
+{
+}
+
+MockX11Server::MockX11Server (Display *d, Glib::RefPtr <Glib::MainLoop> &ml) :
+    X11Server (ml, d)
+{
+}
+
+MockX11Server::~MockX11Server ()
+{
+}
+
+void
+MockX11Server::setRoot (Window root, const compiz::window::Geometry &g)
+{
+    Server::SetDefault (shared_from_this ());
+    X11Server::setRoot (root, g);
+}
+
+compiz::window::Object::Ptr
+MockX11Server::createObject (const compiz::window::ObjectIdentifier::Ptr	 &id,
+			     const compiz::window::Geometry			 &g,
+			     const compiz::window::StackPosition		 &sp,
+			     const boost::shared_ptr <compiz::window::Container> &c)
+{
+    compiz::window::X11ObjectIdentifier::Ptr xid = boost::shared_static_cast <compiz::window::X11ObjectIdentifier> (id);
+    MockX11Object::Ptr			     mxobj = MockX11Object::Ptr (new MockX11Object (id, connect (), g, c));
+    const compiz::window::X11Object::Ptr     &xobj = boost::shared_static_cast <compiz::window::X11Object> (mxobj);
+    std::pair <compiz::window::X11ObjectIdentifier::Ptr, compiz::window::X11Object::Ptr> keyValue (xid, xobj);
+
+    addObjectToTree (keyValue);
+    return (*xid) ();
+}
+
+void
+MockX11Server::removeObject (const compiz::window::ObjectIdentifier::Ptr &id)
+{
+    removeKeyFromTree (id);
+}
+
+Window create_virtual_root (Display		     *display,
+			    compiz::window::Geometry &g)
+{
+    XSetWindowAttributes attr;
+    g.set (0, 0, 800, 600, 0);
+    Window         root     = XCreateWindow (display, DefaultRootWindow (display),
+					     0, 0, g.width (), g.height (), 0, CopyFromParent,
+					     InputOutput, CopyFromParent,
+					     0, &attr);
+    XSelectInput (display, root, ExposureMask);
+    XMapWindow (display, root);
+
+    while (1)
+    {
+	XEvent ev;
+	bool   out = false;
+
+	XNextEvent (display, &ev);
+
+	switch (ev.type)
+	{
+	    case Expose:
+
+		if (ev.xexpose.window == root)
+		{
+		    /* The window is visible, clear it
+		     * with white */
+		    Visual	    *vis = DefaultVisual (display, DefaultScreen (display));
+		    cairo_surface_t *xlib_surface = cairo_xlib_surface_create (display,
+									       root,
+									       vis,
+									       800,
+									       600);
+		    cairo_t *cr = cairo_create (xlib_surface);
+
+		    cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
+		    cairo_paint (cr);
+
+		    cairo_destroy (cr);
+		    cairo_surface_destroy (xlib_surface);
+
+		    out = 1;
+		}
+		break;
+	    default:
+		break;
+	}
+
+	if (out)
+	    break;
+    }
+
+    XSync (display, false);
+
+    return root;
+}
+
+int main (int argc, char **argv)
+{
+    Glib::RefPtr <Glib::MainContext> mc = Glib::MainContext::get_default ();
+    Glib::RefPtr <Glib::MainLoop>    ml = Glib::MainLoop::create (mc, false);
+    Glib::RefPtr <StdinSource>       ss = StdinSource::create (ml);
+    Display        *display = XOpenDisplay (NULL);
+    Window         root     = 0;
+    compiz::window::Geometry rg;
+    MockX11Server::Ptr server = MockX11Server::Ptr (new MockX11Server (display, ml));
+
+    for (int i = 0; i < argc; i++)
+	if (std::string (argv[i]) == "-c" ||
+	    std::string (argv[i]) == "--create")
+	    root = create_virtual_root (display, rg);
+
+    if (!root)
+    {
+	unsigned int width, height;
+	unsigned int uid;
+	Window       wd;
+	int          id;
+
+	root = DefaultRootWindow (display);
+	if (XGetGeometry (display, root, &wd, &id, &id, &width, &height, &uid, &uid))
+	{
+	    rg.setWidth (width);
+	    rg.setHeight (height);
+	}
+    }
+
+    server->setRoot (root, rg);
+
+    server->flush (0);
+    std::cout << ">> " << std::endl;
+    ml->run ();
+
+    XDestroyWindow (display, root);
+    XCloseDisplay (display);
+
+    return 0;
+}