Don't forget to initialize overlay position.

Let clients override the suggested size on resize.

This lets gears enforce a square aspect ration and minimum size of 300x300
and the terminal now properly resizes in steps of character cells.

Snap terminal size to an integer number of character cells.

Handle \e[J and \e[H so we can clear the terminal.

Make sure we don't miss queue redraws between commit and ack.

Destroy back buffer in acknowledge handler.

Only update gears angle in frame handler.

Add key map for ctrl modifier as well.

Update tail pointer correctly so scrolling works.

Skip escape codes for now.

Add keyboard input to terminal.

Run command in a pty and feed output to wayland terminal.

Add some text contents to terminal.

Refactor window logic into reusable parts, add a new terminal application.

The gears code is moved into a new file gearc.c and the window decoration
and management code stays in window.c.  A new application 'terminal' is the
second user of the windowing code, but doesn't do anything useful yet.

Fix API to always include socket name length.

Update .gitignore.

Fail if we can't create the compositor.

Make the wayland server a library used by the compositors.

Use type strings for method and event signatures.

Use autoconf instead of $(shell ...) in the Makefile.

Add note about how clients could embed other applications.

Fix namespace convention for glib source.

Exit if load_compositor() fails.

Update .gitignore.

Drop early, obsolete compositor.

Drop unused clients, pointer and window.

Put Wayland under the MIT license.

Add wl_client_marshal() for sending events.

Generalize event loop a bit and pull in the timerfd stuff.

Finally implement the commit/ack/frame protocol and improve repaint loop.

This implements the commit/ack/frame protocol that let clients batch up
a series of requests and then commit them atomically using the commit request.
The commit requests generats two following events: the acknowledge event,
which lets the client know that the server has received the request and
which frame the rendering has been scheduled for.  At this point the client
can start rendering the next frame or free up temporary buffers.  Then when
the compositor finally makes the newly composited frame visible on screen
the server sends a frame event, which contains the number of the frame that
was presented and the time when it happened.

The window and flower clients have been updated to use these two events in
their main loops and everything now updates per frame.  The EGL compositor
repaint loop has been tweaked to delay the compositing of the screen to
10ms after last swapbuffer completed so as to allow processing as many
requests as possible before blocking on the next vertical retrace.

Make ack event signal that the requests have been composited.

Add .gitignore.

Convert touchpad absolute events to relative.

Use struct buffer from cairo-util.c in flower.c.

Make overlay animation actually stop.

Add commit request + ack event to wayland core.

Use in window.c to manage life cycle of buffer correctly.

Correct pointer hotspot location.

Add different type of overlay animation.

Tweak overlay animation a bit.

Pick a config instead of hard coding one.

Allocate and set mode in egl-compositor.

Pass the front buffer name to eglCreateSurfaceForName to create the
fullscreen EGLSurface.

Quit screenshooter when idle.

Animate overlay on/off.

Add keyboard input, move input device creation to compositor.

Add missing breaks in evdev switch.

Rename input.c to evdev.c.

Expose screenshooting as an interface, drop SIGUSR hack.

This pulls in a bit of extra infrastructure for discovering adertised objects on the
client side.

Generalize the object advertising mechanism.

Add an overlay type window in the compositor.

Load and draw background in compositor.

Move pointer drawing into compositor.

Optimize blur further, resize gears with window.

Remove redundant glFlush().

Optimize blur a bit more.

A couple more theme tweaks.

Get corner radius right for inner bevel.

Add quick screenshot hack.

Optimize window blur calculation.

Factor out common cairo code, add blur function.

Make window prettier again.

Tweak pointer image a bit.

Add prototypes warnings, use -fvisibility.

Use the eagle pkg-config file instead of assuming ../eagle.

Implement surface copy request, use it for egl gears.

Use glib main loop for all clients.

Add glib main loop integration, use it in flower client.

Add copy and damage surface requests.

dlopen the compositor, add a glx compositor.

README: Add link to google group.

Add a FIXME for when we have a working fbconfig chooser.

Clear depth buffer, but only depth buffer for gears.

Add the gears from glxgears.

Add README for the adventurous, allow evdev override from getenv().

Redraw window in idle handler.

Use eglBindTexImage instead of copying texture data.

Make window client a little more interesting.

Use GL_ONE for the source in glBendFunc instead of pre-unmultiplying.

Eventually we need to allow both pre-multiplied alpha and not, but for now default to premultiplied.

Add a window client, first implementation of surface resizing.

Always poll on display fd so we only read when there's data.

Move background drawing to a client.

Unpremultiply cairo surface data.

Don't use poll timeout for timing animation.

Receiving events breaks out of the poll and resets the time out.
Effectively, this blocks the animation when the client receives events.
As a quick fix, use timerfd for timing the animation.

Add a new client that draws a pointer.

Rename client, prepare Makefile for more clients.

Add crude input device support.

Just pointer motion and button clicks for now, broadcast to all clients.

Drop unused struct definition.

Update for eagle changes.

Add note about fullscreen surfaces, misc edits.

Make clients graphics use lighter random colors.

Use triangle strips for drawing surfaces.

Make test client a little more interesting.

Track client objects and destroy them on disconnect.

We're going to need a virtual destructor eventually...

Run compositor fullscreen, repaint when surfaces come and go.

Add notes on throttling, scheduling and atomicity.

Recomposite screen in idle handler.

Handle multiple clients better.

Add an EGL compositor.  Still pretty lame.

Use new connection object in client code too.

Split out connection io buffer logic.

Make in and out circular buffers actually work.