Source tree restructuring and switch to new drawable interface

60 files changed, 5250 insertions, 5155 deletions

diff --git a/ChangeLog b/ChangeLog
index 919c6ae..7342b7d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2004-11-03  David Reveman  <c99drn@cs.umu.se>
+
+	* Source tree restructuring and switch to new drawable interface.
+
 2004-10-21  David Reveman  <c99drn@cs.umu.se>
 
 	* src/glitz_pixel.c (glitz_get_pixels): Set read buffer and
diff --git a/Makefile.am b/Makefile.am
index 8bb0fb3..5c7d167 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,29 +1,3 @@
 SUBDIRS = . src
 
-if GLITZ_BUILD_GLX_BACKEND
-libglitz_glx_extra_dist = glitz-glx.pc.in
-libglitz_glx_data = glitz-glx.pc
-else
-libglitz_glx_extra_dist =
-libglitz_glx_data =
-endif
-
-if GLITZ_BUILD_AGL_BACKEND
-libglitz_agl_extra_dist = glitz-agl.pc.in
-libglitz_agl_data = glitz-agl.pc
-else
-libglitz_agl_extra_dist =
-libglitz_agl_data =
-endif
-
-EXTRA_DIST = \
-	COPYING \
-	glitz.pc.in \
-	$(libglitz_glx_extra_dist)
-	$(libglitz_agl_extra_dist)
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = \
-	glitz.pc \
-	$(libglitz_glx_data) \
-	$(libglitz_agl_data)
+EXTRA_DIST = COPYING
\ No newline at end of file
diff --git a/TODO b/TODO
index 83c3991..80a22e5 100644
--- a/TODO
+++ b/TODO
@@ -1,3 +1,5 @@
+* API documentation.
+
 * Allow the fragment filters to be applied to mask surfaces
   and not only source surfaces. The filter system and the fragment
   programs are design to work both with source and mask surfaces,
diff --git a/configure.in b/configure.in
index d539bbc..795c480 100644
--- a/configure.in
+++ b/configure.in
@@ -6,7 +6,7 @@ dnl ===========================================================================
 
 # Package version number, (as distinct from shared library version)
 # This must be manually synchronized with the version in src/glitz.h
-GLITZ_VERSION=0.2.3
+GLITZ_VERSION=0.3.0
 # libtool shared library version
 
 # Increment if the interface has additions, changes, removals.
@@ -93,6 +93,14 @@ AC_C_BIGENDIAN
 
 dnl ===========================================================================
 
+GLITZ_LIB='-L$(top_builddir)/src -lglitz'
+GLITZ_INC='-I$(top_builddir)/src -I$(top_srcdir)/src'
+
+AC_SUBST(GLITZ_LIB)
+AC_SUBST(GLITZ_INC)
+
+dnl ===========================================================================
+
 AC_ARG_ENABLE(glx,
   AC_HELP_STRING([--disable-glx], [Disable glitz's GLX backend]),
   [use_glx=$enableval], [use_glx=yes])
@@ -193,9 +201,11 @@ dnl ===========================================================================
 AC_OUTPUT([
 Makefile
 src/Makefile
-glitz.pc
-glitz-glx.pc
-glitz-agl.pc
+src/glx/Makefile
+src/agl/Makefile
+src/glitz.pc
+src/glx/glitz-glx.pc
+src/agl/glitz-agl.pc
 ])
 
 dnl ===========================================================================
diff --git a/src/Makefile.am b/src/Makefile.am
index 8dd3ee9..5d747b8 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,85 +1,35 @@
-if GLITZ_BUILD_GLX_BACKEND
-libglitz_glx_library = libglitz-glx.la
-libglitz_glx_header = glitz-glx.h
-else
-libglitz_glx_library =
-libglitz_glx_header =
-endif
+SUBDIRS = . glx agl
 
-if GLITZ_BUILD_AGL_BACKEND
-libglitz_agl_library = libglitz-agl.la
-libglitz_agl_header = glitz-agl.h
-else
-libglitz_agl_library =
-libglitz_agl_header =
-endif
+lib_LTLIBRARIES = libglitz.la
+include_HEADERS = glitz.h
 
-lib_LTLIBRARIES = \
-	libglitz.la \
-	$(libglitz_glx_library) \
-	$(libglitz_agl_library)
-
-include_HEADERS = \
-	glitz.h \
-	$(libglitz_glx_header) \
-	$(libglitz_agl_header)
-
-libglitz_la_SOURCES = \
-	glitz.c \
-	glitz.h \
+libglitz_la_SOURCES =	 \
+	glitz.h		 \
+	glitz.c		 \
 	glitz_operator.c \
-	glitz_surface.c \
-	glitz_texture.c \
-	glitz_rect.c \
-	glitz_status.c \
-	glitz_util.c \
-	glitz_format.c \
-	glitz_program.c \
-	glitz_compose.c \
-	glitz_filter.c \
-	glitz_buffer.c \
+	glitz_drawable.c \
+	glitz_surface.c	 \
+	glitz_texture.c	 \
+	glitz_rect.c	 \
+	glitz_status.c	 \
+	glitz_util.c	 \
+	glitz_region.c	 \
+	glitz_format.c	 \
+	glitz_program.c	 \
+	glitz_compose.c	 \
+	glitz_filter.c	 \
+	glitz_buffer.c	 \
 	glitz_geometry.c \
-	glitz_pixel.c \
-	glitz_gl.h \
+	glitz_pixel.c	 \
+	glitz_gl.h	 \
 	glitzint.h
 
 libglitz_la_LDFLAGS = -version-info @VERSION_INFO@ -no-undefined
-libglitz_la_CFLAGS =
 libglitz_la_LIBADD = -lm
 
-if GLITZ_BUILD_GLX_BACKEND
-libglitz_glx_la_SOURCES = \
-	glitz.h \
-	glitz_gl.h \
-	glitzint.h \
-	glitz-glx.h \
-	glitz_glx_surface.c \
-	glitz_glx_format.c \
-	glitz_glx_info.c \
-	glitz_glx_extension.c \
-	glitz_glx_context.c \
-	glitz_glx_pbuffer.c \
-	glitz_glxext.h \
-	glitz_glxint.h
-libglitz_glx_la_LDFLAGS = -version-info @VERSION_INFO@ -no-undefined
-libglitz_glx_la_CFLAGS = $(GLX_CFLAGS)
-libglitz_glx_la_LIBADD = -lglitz $(GLX_LIBS)
-endif
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = glitz.pc
 
-if GLITZ_BUILD_AGL_BACKEND
-libglitz_agl_la_SOURCES = \
-	glitz.h \
-	glitz_gl.h \
-	glitzint.h \
-	glitz-agl.h \
-	glitz_agl_surface.c \
-	glitz_agl_format.c \
-	glitz_agl_info.c \
-	glitz_agl_extension.c \
-	glitz_agl_context.c \
-	glitz_agl_pbuffer.c \
-	glitz_aglint.h
-libglitz_agl_la_LDFLAGS = -version-info @VERSION_INFO@
-libglitz_agl_la_CFLAGS = $(AGL_CFLAGS)
-libglitz_agl_la_LIBADD = -lglitz $(AGL_LIBS)
-endif
+EXTRA_DIST =	     \
+	glitz.pc.in  \
+	glitz.man
\ No newline at end of file
diff --git a/src/agl/Makefile.am b/src/agl/Makefile.am
new file mode 100644
index 0000000..ee4134a
--- /dev/null
+++ b/src/agl/Makefile.am
@@ -0,0 +1,38 @@
+if GLITZ_BUILD_AGL_BACKEND
+
+INCLUDES =	      \
+	$(GLITZ_INC)  \
+	$(AGL_CFLAGS)
+
+lib_LTLIBRARIES = libglitz-agl.la
+include_HEADERS = glitz-agl.h
+
+libglitz_agl_la_SOURCES =     \
+	glitz-agl.h	      \
+	glitz_agl_drawable.c  \
+	glitz_agl_format.c    \
+	glitz_agl_info.c      \
+	glitz_agl_extension.c \
+	glitz_agl_context.c   \
+	glitz_agl_pbuffer.c   \
+	glitz_aglint.h
+
+libglitz_agl_la_LDFLAGS = -version-info @VERSION_INFO@
+libglitz_agl_la_LIBADD = $(GLITZ_LIB) $(AGL_LIBS)
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = glitz-agl.pc
+
+endif
+
+EXTRA_DIST =		      \
+	glitz-agl.h	      \
+	glitz_agl_drawable.c  \
+	glitz_agl_format.c    \
+	glitz_agl_info.c      \
+	glitz_agl_extension.c \
+	glitz_agl_context.c   \
+	glitz_agl_pbuffer.c   \
+	glitz_aglint.h	      \
+	glitz-agl.pc.in	      \
+	glitz-agl.man
diff --git a/src/agl/glitz-agl.h b/src/agl/glitz-agl.h
new file mode 100644
index 0000000..0d6b637
--- /dev/null
+++ b/src/agl/glitz-agl.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifndef GLITZ_AGL_H_INCLUDED
+#define GLITZ_AGL_H_INCLUDED
+
+#include <glitz.h>
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include <Carbon/Carbon.h>
+
+
+/* glitz_agl_info.c */
+
+void
+glitz_agl_init (void);
+
+void
+glitz_agl_fini (void);
+  
+  
+/* glitz_agl_format.c */
+
+glitz_drawable_format_t *
+glitz_agl_find_drawable_format (unsigned long                 mask,
+                                const glitz_drawable_format_t *templ,
+                                int                           count);
+  
+
+/* glitz_agl_drawable.c */
+
+glitz_drawable_t *
+glitz_agl_create_drawable_for_window (glitz_drawable_format_t *format,
+                                      WindowRef               window,
+                                      int                     width,
+                                      int                     height);
+
+glitz_drawable_t *
+glitz_agl_create_pbuffer_drawable (glitz_drawable_format_t    *format,
+                                   glitz_pbuffer_attributes_t *attributes,
+                                   unsigned long              mask);
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif /* GLITZ_AGL_H_INCLUDED */
diff --git a/src/agl/glitz-agl.man b/src/agl/glitz-agl.man
new file mode 100644
index 0000000..5cfbb19
--- /dev/null
+++ b/src/agl/glitz-agl.man
@@ -0,0 +1,26 @@
+.\"
+.\"
+.de TQ
+.br
+.ns
+.TP
+\\$1
+..
+.TH GLITZ-AGL 3 "Version 1.0"
+
+.SH NAME
+GLITZ-AGL \- AGL interface to glitz
+
+.SH SYNOPSIS
+.nf
+.B #include <glitz-agl.h>
+.fi
+.SH DESCRIPTION
+
+AGL interface to glitz.
+
+.SH AUTHOR
+David Reveman
+
+.SH "SEE ALSO"
+.BR GLITZ (3)
\ No newline at end of file
diff --git a/glitz-agl.pc.in b/src/agl/glitz-agl.pc.in
index abe98cc..abe98cc 100644
--- a/glitz-agl.pc.in
+++ b/src/agl/glitz-agl.pc.in
diff --git a/src/agl/glitz_agl_context.c b/src/agl/glitz_agl_context.c
new file mode 100644
index 0000000..d6be7d1
--- /dev/null
+++ b/src/agl/glitz_agl_context.c
@@ -0,0 +1,318 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_aglint.h"
+
+extern glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address;
+
+static CFBundleRef
+_glitz_agl_get_bundle (const char *name)
+{
+  CFBundleRef bundle = 0;
+  FSRefParam ref_param;
+  unsigned char framework_name[256];
+
+  framework_name[0] = strlen (name);
+  strcpy (&framework_name[1], name);
+  
+  memset (&ref_param, 0, sizeof (ref_param));
+
+  if (FindFolder (kSystemDomain,
+                  kFrameworksFolderType,
+                  kDontCreateFolder,
+                  &ref_param.ioVRefNum,
+                  &ref_param.ioDirID) == noErr) {
+    FSRef ref;
+
+    memset (&ref, 0, sizeof (ref));
+
+    ref_param.ioNamePtr = framework_name;
+    ref_param.newRef = &ref;
+
+    if (PBMakeFSRefSync (&ref_param) == noErr) {
+      CFURLRef url;
+
+      url = CFURLCreateFromFSRef (kCFAllocatorDefault, &ref);
+      if (url) {
+        bundle = CFBundleCreate (kCFAllocatorDefault, url);
+        CFRelease (url);
+
+        if (!CFBundleLoadExecutable (bundle)) {
+          CFRelease (bundle);
+          return (CFBundleRef) 0;
+        }
+      }
+    }
+  }
+    
+  return bundle;
+}
+
+static void
+_glitz_agl_release_bundle (CFBundleRef bundle)
+{
+  if (bundle) {
+    CFBundleUnloadExecutable (bundle);
+    CFRelease (bundle);
+  }
+}
+
+static glitz_function_pointer_t
+_glitz_agl_get_proc_address (const char *name, void *closure)
+{
+  glitz_function_pointer_t address = NULL;
+  CFBundleRef bundle = (CFBundleRef) closure;
+  CFStringRef str;
+  
+  if (bundle) {
+    str = CFStringCreateWithCString (kCFAllocatorDefault, name,
+                                     kCFStringEncodingMacRoman);
+
+    address = CFBundleGetFunctionPointerForName (bundle, str);
+
+    CFRelease (str);
+  }
+  
+  return address;
+}
+
+glitz_agl_context_t *
+glitz_agl_context_get (glitz_agl_thread_info_t *thread_info,
+                       glitz_drawable_format_t *format)
+{
+  glitz_agl_context_t *context;
+  glitz_agl_context_t **contexts = thread_info->contexts;
+  int index, n_contexts = thread_info->n_contexts;
+
+  for (; n_contexts; n_contexts--, contexts++)
+    if ((*contexts)->id == format->id)
+      return *contexts;
+  
+  index = thread_info->n_contexts++;
+
+  thread_info->contexts =
+    realloc (thread_info->contexts,
+             sizeof (glitz_agl_context_t *) * thread_info->n_contexts);
+  if (!thread_info->contexts)
+    return NULL;
+
+  context = malloc (sizeof (glitz_agl_context_t));
+  if (!context)
+    return NULL;
+  
+  thread_info->contexts[index] = context;
+
+  context->context =
+    aglCreateContext (thread_info->pixel_formats[format->id],
+                      thread_info->root_context);
+  if (!context->context) {
+    free (context);
+    return NULL;
+  } 
+  
+  context->id = format->id;
+  context->pbuffer = 0;
+
+  if (!thread_info->root_context)
+    thread_info->root_context = context->context;
+
+  memcpy (&context->backend.gl,
+          &_glitz_agl_gl_proc_address,
+          sizeof (glitz_gl_proc_address_list_t));
+
+  context->backend.create_pbuffer = glitz_agl_create_pbuffer;
+  context->backend.destroy = glitz_agl_destroy;
+  context->backend.push_current = glitz_agl_push_current;
+  context->backend.pop_current = glitz_agl_pop_current;
+  context->backend.swap_buffers = glitz_agl_swap_buffers;
+  context->backend.make_current_read = glitz_agl_make_current_read;
+
+  context->backend.drawable_formats = thread_info->formats;
+  context->backend.n_drawable_formats = thread_info->n_formats;
+
+  context->backend.texture_formats = NULL;
+  context->backend.formats = NULL;
+  context->backend.n_formats = 0;
+  
+  context->backend.program_map = &thread_info->program_map;
+  context->backend.feature_mask = 0;
+
+  context->initialized = 0;
+  
+  return context;
+}
+
+void
+glitz_agl_context_destroy (glitz_agl_thread_info_t *thread_info,
+                           glitz_agl_context_t *context)
+{
+  if (context->backend.formats)
+    free (context->backend.formats);
+
+  if (context->backend.texture_formats)
+    free (context->backend.texture_formats);
+  
+  aglDestroyContext (context->context);
+  
+  free (context);
+}
+
+static void
+_glitz_agl_context_initialize (glitz_agl_thread_info_t *thread_info,
+                               glitz_agl_context_t     *context)
+{
+  CFBundleRef bundle;
+  
+  bundle = _glitz_agl_get_bundle ("OpenGL.framework");
+
+  glitz_backend_init (&context->backend,
+                      _glitz_agl_get_proc_address,
+                      (void *) bundle);
+
+  _glitz_agl_release_bundle (bundle);
+
+  context->backend.gl.get_integer_v (GLITZ_GL_MAX_VIEWPORT_DIMS,
+                                     context->max_viewport_dims);
+
+  glitz_initiate_state (&_glitz_agl_gl_proc_address);
+    
+  context->initialized = 1;
+}
+
+static void
+_glitz_agl_context_make_current (glitz_agl_drawable_t *drawable,
+                                 glitz_bool_t         flush)
+{
+  if (flush)
+    glFlush ();
+  
+  if (drawable->pbuffer) {
+    aglSetPBuffer (drawable->context->context, drawable->pbuffer, 0, 0,
+                   aglGetVirtualScreen (drawable->context->context));
+    drawable->context->pbuffer = 1;
+  } else {
+    if (drawable->context->pbuffer) {
+      aglSetDrawable (drawable->context->context, NULL);
+      drawable->context->pbuffer = 0;
+    }
+    
+    aglSetDrawable (drawable->context->context, drawable->drawable);
+  }
+
+  aglSetCurrentContext (drawable->context->context);
+
+  drawable->base.update_all = 1;
+  
+  if (!drawable->context->initialized)
+    _glitz_agl_context_initialize (drawable->thread_info, drawable->context);
+}
+
+static void
+_glitz_agl_context_update (glitz_agl_drawable_t *drawable,
+                           glitz_constraint_t   constraint)
+{
+  AGLContext context;
+
+  switch (constraint) {
+  case GLITZ_NONE:
+    break;
+  case GLITZ_ANY_CONTEXT_CURRENT:
+    context = aglGetCurrentContext ();
+    if (context == (AGLContext) 0)
+      _glitz_agl_context_make_current (drawable, 0);
+    break;
+  case GLITZ_CONTEXT_CURRENT:
+    context = aglGetCurrentContext ();
+    if (context != drawable->context->context)
+      _glitz_agl_context_make_current (drawable, (context)? 1: 0);
+    break;
+  case GLITZ_DRAWABLE_CURRENT:
+    context = aglGetCurrentContext ();
+    if (context != drawable->context->context) {
+      _glitz_agl_context_make_current (drawable, (context)? 1: 0);
+    } else {
+      if (drawable->pbuffer) {
+        AGLPbuffer pbuffer;
+        GLuint unused;
+
+        aglGetPBuffer (drawable->context->context, &pbuffer,
+                       &unused, &unused, &unused);
+        
+        if (pbuffer != drawable->pbuffer)
+          _glitz_agl_context_make_current (drawable, (context)? 1: 0);
+        
+      } else if (drawable->drawable) {
+        if (aglGetDrawable (drawable->context->context) != drawable->drawable)
+          _glitz_agl_context_make_current (drawable, (context)? 1: 0);
+      }
+    }
+    break;
+  }
+}
+
+void
+glitz_agl_push_current (void               *abstract_drawable,
+                        glitz_surface_t    *surface,
+                        glitz_constraint_t constraint)
+{
+  glitz_agl_drawable_t *drawable = (glitz_agl_drawable_t *) abstract_drawable;
+  glitz_agl_context_info_t *context_info;
+  int index;
+
+  index = drawable->thread_info->context_stack_size++;
+
+  context_info = &drawable->thread_info->context_stack[index];
+  context_info->drawable = drawable;
+  context_info->surface = surface;
+  context_info->constraint = constraint;
+  
+  _glitz_agl_context_update (context_info->drawable, constraint);
+}
+
+glitz_surface_t *
+glitz_agl_pop_current (void *abstract_drawable)
+{
+  glitz_agl_drawable_t *drawable = (glitz_agl_drawable_t *) abstract_drawable;
+  glitz_agl_context_info_t *context_info = NULL;
+  int index;
+
+  drawable->thread_info->context_stack_size--;
+  index = drawable->thread_info->context_stack_size - 1;
+
+  context_info = &drawable->thread_info->context_stack[index];
+
+  if (context_info->drawable)
+    _glitz_agl_context_update (context_info->drawable,
+                               context_info->constraint);
+  
+  if (context_info->constraint == GLITZ_DRAWABLE_CURRENT)
+      return context_info->surface;
+  
+  return NULL;
+}
diff --git a/src/agl/glitz_agl_drawable.c b/src/agl/glitz_agl_drawable.c
new file mode 100644
index 0000000..661181d
--- /dev/null
+++ b/src/agl/glitz_agl_drawable.c
@@ -0,0 +1,227 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_aglint.h"
+
+glitz_status_t
+glitz_agl_make_current_read (void *abstract_surface)
+{
+  return GLITZ_STATUS_NOT_SUPPORTED;
+}
+
+static glitz_agl_drawable_t *
+_glitz_agl_create_drawable (glitz_agl_thread_info_t *thread_info,
+                            glitz_agl_context_t     *context,
+                            glitz_drawable_format_t *format,
+                            AGLDrawable             agl_drawable,
+                            AGLPbuffer              agl_pbuffer,
+                            int                     width,
+                            int                     height)
+{
+  glitz_agl_drawable_t *drawable;
+  
+  if (width <= 0 || height <= 0)
+    return NULL;
+
+  drawable = (glitz_agl_drawable_t *) malloc (sizeof (glitz_agl_drawable_t));
+  if (drawable == NULL)
+    return NULL;
+
+  drawable->base.ref_count = 1;
+  drawable->thread_info = thread_info;
+  drawable->context = context;
+  drawable->drawable = agl_drawable;
+  drawable->pbuffer = agl_pbuffer;
+  drawable->base.format = format;
+  drawable->base.backend = &context->backend;
+
+  glitz_drawable_update_size (&drawable->base, width, height);
+  
+  if (!context->initialized) {
+    glitz_agl_push_current (drawable, NULL, GLITZ_CONTEXT_CURRENT);
+    glitz_agl_pop_current (drawable);
+  }
+  
+  if (width > context->max_viewport_dims[0] ||
+      height > context->max_viewport_dims[1]) {
+    free (drawable);
+    return NULL;
+  }
+
+  thread_info->drawables++;
+  
+  return drawable;
+}
+
+static glitz_drawable_t *
+_glitz_agl_create_pbuffer_drawable (glitz_agl_thread_info_t    *thread_info,
+                                    glitz_drawable_format_t    *format,
+                                    glitz_pbuffer_attributes_t *attributes,
+                                    unsigned long              mask)
+{
+  glitz_agl_drawable_t *drawable;
+  glitz_agl_context_t *context;
+  AGLPbuffer pbuffer;
+  int width, height;
+
+  if (!format->types.pbuffer)
+    return NULL;
+  
+  context = glitz_agl_context_get (thread_info, format);
+  if (!context)
+    return NULL;
+
+  pbuffer = glitz_agl_pbuffer_create (thread_info, attributes, mask,
+                                      &width, &height);
+  if (!pbuffer)
+    return NULL;
+  
+  drawable = _glitz_agl_create_drawable (thread_info, context, format,
+                                         (AGLDrawable) 0, pbuffer,
+                                         width, height);
+  if (!drawable) {
+    glitz_agl_pbuffer_destroy (pbuffer);
+    return NULL;
+  }
+  
+  return &drawable->base;
+}
+
+glitz_drawable_t *
+glitz_agl_create_pbuffer (void                       *abstract_templ,
+                          glitz_drawable_format_t    *format,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask)
+{
+  glitz_agl_drawable_t *templ = (glitz_agl_drawable_t *) abstract_templ;
+
+  return _glitz_agl_create_pbuffer_drawable (templ->thread_info, format,
+                                             attributes, mask);
+}
+
+glitz_drawable_t *
+glitz_agl_create_drawable_for_window (glitz_drawable_format_t *format,
+                                      WindowRef               window,
+                                      int                     width,
+                                      int                     height)
+{
+  glitz_agl_drawable_t *drawable;
+  glitz_agl_thread_info_t *thread_info;
+  glitz_agl_context_t *context;
+  AGLDrawable agl_drawable;
+
+  agl_drawable = (AGLDrawable) GetWindowPort (window);
+  if (!agl_drawable)
+    return NULL;
+
+  thread_info = glitz_agl_thread_info_get ();
+  if (!thread_info)
+    return NULL;
+
+  context = glitz_agl_context_get (thread_info, format);
+  if (!context)
+    return NULL;
+
+  drawable = _glitz_agl_create_drawable (thread_info, context, format,
+                                         agl_drawable, (AGLPbuffer) 0,
+                                         width, height);
+  if (!drawable)
+    return NULL;
+
+  return &drawable->base;
+}
+slim_hidden_def(glitz_agl_create_drawable_for_window);
+
+glitz_drawable_t *
+glitz_agl_create_pbuffer_drawable (glitz_drawable_format_t    *format,
+                                   glitz_pbuffer_attributes_t *attributes,
+                                   unsigned long              mask)
+{
+  glitz_agl_thread_info_t *thread_info;
+
+  thread_info = glitz_agl_thread_info_get ();
+  if (!thread_info)
+    return NULL;
+
+  return _glitz_agl_create_pbuffer_drawable (thread_info, format,
+                                             attributes, mask);
+}
+slim_hidden_def(glitz_agl_create_pbuffer_drawable);
+
+void
+glitz_agl_destroy (void *abstract_drawable)
+{
+  glitz_agl_drawable_t *drawable = (glitz_agl_drawable_t *) abstract_drawable;
+
+  drawable->thread_info->drawables--;
+  if (drawable->thread_info->drawables == 0) {
+    /*
+     * Last drawable? We have to destroy all fragment programs as this may
+     * be our last chance to have a context current.
+     */
+    glitz_agl_push_current (abstract_drawable, NULL, GLITZ_CONTEXT_CURRENT);
+    glitz_program_map_fini (&drawable->base.backend->gl,
+                            &drawable->thread_info->program_map);
+    glitz_agl_pop_current (abstract_drawable);
+  }
+
+  if (drawable->drawable || drawable->pbuffer) {
+    AGLContext context = aglGetCurrentContext ();
+    
+    if (context == drawable->context->context) { 
+      if (drawable->pbuffer) {
+        AGLPbuffer pbuffer;
+        GLuint unused;
+        
+        aglGetPBuffer (context, &pbuffer, &unused, &unused, &unused);
+        
+        if (pbuffer == drawable->pbuffer)
+          aglSetCurrentContext (NULL);
+      } else {
+        if (aglGetDrawable (context) == drawable->drawable)
+          aglSetCurrentContext (NULL);
+      }
+    }
+    
+    if (drawable->pbuffer)
+      glitz_agl_pbuffer_destroy (drawable->pbuffer);
+  }
+  
+  free (drawable);
+}
+
+void
+glitz_agl_swap_buffers (void *abstract_drawable)
+{
+  glitz_agl_drawable_t *drawable = (glitz_agl_drawable_t *) abstract_drawable;
+
+  glitz_agl_push_current (abstract_drawable, NULL, GLITZ_DRAWABLE_CURRENT);
+  aglSwapBuffers (drawable->context->context);
+  glitz_agl_pop_current (abstract_drawable);
+}
diff --git a/src/agl/glitz_agl_extension.c b/src/agl/glitz_agl_extension.c
new file mode 100644
index 0000000..22b800e
--- /dev/null
+++ b/src/agl/glitz_agl_extension.c
@@ -0,0 +1,92 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_aglint.h"
+
+static glitz_extension_map agl_extensions[] = {
+  { 0.0, "GL_APPLE_pixel_buffer", GLITZ_AGL_FEATURE_PBUFFER_MASK },
+  { 0.0, "GL_ARB_multisample", GLITZ_AGL_FEATURE_MULTISAMPLE_MASK },
+  { 0.0, "GL_ARB_texture_rectangle",
+    GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK },
+  { 0.0, "GL_EXT_texture_rectangle",
+    GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK },
+  { 0.0, "GL_NV_texture_rectangle", GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK },
+  { 0.0, NULL, 0 }
+};
+
+glitz_status_t
+glitz_agl_query_extensions (glitz_agl_thread_info_t *thread_info)
+{
+  GLint attrib[] = {
+    AGL_RGBA,
+    AGL_NO_RECOVERY,
+    AGL_NONE
+  };
+  AGLPixelFormat pf;
+  AGLContext context;
+
+  thread_info->agl_feature_mask = 0;
+
+  pf = aglChoosePixelFormat (NULL, 0, attrib);
+  context = aglCreateContext (pf, NULL);
+  
+  if (context) {
+    const char *gl_extensions_string;
+
+    aglSetCurrentContext (context);
+  
+    gl_extensions_string = (const char *) glGetString (GL_EXTENSIONS);
+
+    thread_info->agl_feature_mask =
+      glitz_extensions_query (0.0,
+                              gl_extensions_string,
+                              agl_extensions);
+
+    if (thread_info->agl_feature_mask & GLITZ_AGL_FEATURE_MULTISAMPLE_MASK) {
+      const char *vendor;
+
+      vendor = glGetString (GL_VENDOR);
+    
+      if (vendor) {
+        
+        /* NVIDIA's driver seem to support multisample with pbuffers */
+        if (!strncmp ("NVIDIA", vendor, 6))
+          thread_info->agl_feature_mask |=
+            GLITZ_AGL_FEATURE_PBUFFER_MULTISAMPLE_MASK;
+      }
+    }
+
+    aglSetCurrentContext (NULL);
+    aglDestroyContext (context);
+  }
+
+  aglDestroyPixelFormat (pf);
+
+  return GLITZ_STATUS_SUCCESS;
+}
diff --git a/src/agl/glitz_agl_format.c b/src/agl/glitz_agl_format.c
new file mode 100644
index 0000000..072c14f
--- /dev/null
+++ b/src/agl/glitz_agl_format.c
@@ -0,0 +1,333 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_aglint.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static GLint _attribs[] = {
+  AGL_RGBA,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_NONE
+};
+
+static GLint _db_attribs[] = {
+  AGL_RGBA,
+  AGL_DOUBLEBUFFER,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_NONE
+};
+
+static GLint _stencil_attribs[] = {
+  AGL_RGBA,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_DEPTH_SIZE, 8,
+  AGL_STENCIL_SIZE, 8,
+  AGL_NONE
+};
+
+static GLint _db_stencil_attribs[] = {
+  AGL_RGBA,
+  AGL_DOUBLEBUFFER,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_STENCIL_SIZE, 8,
+  AGL_NONE
+};
+
+static GLint _ms2_attribs[] = {
+  AGL_RGBA,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_STENCIL_SIZE, 8,
+  AGL_SAMPLE_BUFFERS_ARB, 1,
+  AGL_SAMPLES_ARB, 2,
+  AGL_NONE
+};
+
+static GLint _db_ms2_attribs[] = {
+  AGL_RGBA,
+  AGL_DOUBLEBUFFER,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_STENCIL_SIZE, 8,
+  AGL_SAMPLE_BUFFERS_ARB, 1,
+  AGL_SAMPLES_ARB, 2,
+  AGL_NONE
+};
+
+static GLint _ms4_attribs[] = {
+  AGL_RGBA,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_STENCIL_SIZE, 8,
+  AGL_SAMPLE_BUFFERS_ARB, 1,
+  AGL_SAMPLES_ARB, 4,
+  AGL_NONE
+};
+
+static GLint _db_ms4_attribs[] = {
+  AGL_RGBA,
+  AGL_DOUBLEBUFFER,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_STENCIL_SIZE, 8,
+  AGL_SAMPLE_BUFFERS_ARB, 1,
+  AGL_SAMPLES_ARB, 4,
+  AGL_NONE
+};
+
+static GLint _ms6_attribs[] = {
+  AGL_RGBA,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_STENCIL_SIZE, 8,
+  AGL_SAMPLE_BUFFERS_ARB, 1,
+  AGL_SAMPLES_ARB, 6,
+  AGL_NONE
+};
+
+static GLint _db_ms6_attribs[] = {
+  AGL_RGBA,
+  AGL_DOUBLEBUFFER,
+  AGL_ALPHA_SIZE, 16,
+  AGL_RED_SIZE, 16,
+  AGL_STENCIL_SIZE, 8,
+  AGL_SAMPLE_BUFFERS_ARB, 1,
+  AGL_SAMPLES_ARB, 6,
+  AGL_NONE
+};
+
+static GLint *_attribs_list[] = {
+  _attribs,
+  _db_attribs,
+  _stencil_attribs,
+  _db_stencil_attribs,
+  _ms2_attribs,
+  _db_ms2_attribs,
+  _ms4_attribs,
+  _db_ms4_attribs,
+  _ms6_attribs,
+  _db_ms6_attribs
+};
+
+static int
+_glitz_agl_format_compare (const void *elem1,
+                           const void *elem2)
+{
+  int i, score[2];
+  glitz_drawable_format_t *format[2];
+  
+  format[0] = (glitz_drawable_format_t *) elem1;
+  format[1] = (glitz_drawable_format_t *) elem2;
+  i = score[0] = score[1] = 0;
+
+  for (; i < 2; i++) {
+    if (format[i]->color.red_size) {
+      if (format[i]->color.red_size == 8)
+        score[i] += 5;
+      score[i] += 10;
+    }
+
+    if (format[i]->color.green_size) {
+      if (format[i]->color.green_size == 8)
+        score[i] += 5;
+      score[i] += 10;
+    }
+    
+    if (format[i]->color.alpha_size) {
+      if (format[i]->color.alpha_size == 8)
+        score[i] += 5;
+      score[i] += 10;
+    }
+
+    if (format[i]->stencil_size)
+      score[i] += 5;
+
+    if (format[i]->depth_size)
+      score[i] += 5;
+
+    if (format[i]->doublebuffer)
+      score[i] += 10;
+    
+    if (format[i]->types.window)
+      score[i] += 10;
+    
+    if (format[i]->types.pbuffer)
+      score[i] += 10;
+    
+    if (format[i]->samples > 1) 
+      score[i] -= (20 - format[i]->samples);
+  }
+  
+  return score[1] - score[0];
+}
+
+static void
+_glitz_add_format (glitz_agl_thread_info_t *thread_info,
+                   glitz_drawable_format_t *format,
+                   AGLPixelFormat          pixel_format)
+{
+  if (!glitz_drawable_format_find (thread_info->formats,
+                                   thread_info->n_formats,
+                                   GLITZ_DRAWABLE_FORMAT_ALL_EXCEPT_ID_MASK,
+                                   format, 0)) {
+    int n = thread_info->n_formats;
+      
+    thread_info->formats =
+      realloc (thread_info->formats,
+               sizeof (glitz_drawable_format_t) * (n + 1));
+    thread_info->pixel_formats =
+      realloc (thread_info->pixel_formats,
+               sizeof (AGLPixelFormat) * (n + 1));
+
+    if (thread_info->formats && thread_info->pixel_formats) {
+      thread_info->formats[n] = *format;
+      thread_info->formats[n].id = n;
+      thread_info->pixel_formats[n] = pixel_format;
+      thread_info->n_formats++;
+    }
+  }
+}
+
+void
+glitz_agl_query_formats (glitz_agl_thread_info_t *thread_info)
+{
+  glitz_drawable_format_t format;
+  AGLPixelFormat pixel_format, *new_pfs;
+  int n_attribs_list, i;
+
+  format.types.window = 1;
+  format.id = 0;
+
+  n_attribs_list = sizeof (_attribs_list) / sizeof (GLint *);
+
+  for (i = 0; i < n_attribs_list; i++) {
+    GLint value;
+    
+    pixel_format = aglChoosePixelFormat (NULL, 0, _attribs_list[i]);
+
+    /* Stereo is not supported yet */
+    if (!(aglDescribePixelFormat (pixel_format, AGL_STEREO, &value)) ||
+        value) {
+      aglDestroyPixelFormat (pixel_format);
+      continue;
+    }
+    
+    aglDescribePixelFormat (pixel_format, AGL_DOUBLEBUFFER, &value);
+    format.doublebuffer = (value)? 1: 0;
+    
+    aglDescribePixelFormat (pixel_format, AGL_RED_SIZE, &value);
+    format.color.red_size = (unsigned short) value;
+    aglDescribePixelFormat (pixel_format, AGL_GREEN_SIZE, &value);
+    format.color.green_size = (unsigned short) value;
+    aglDescribePixelFormat (pixel_format, AGL_BLUE_SIZE, &value);
+    format.color.blue_size = (unsigned short) value;
+    aglDescribePixelFormat (pixel_format, AGL_ALPHA_SIZE, &value);
+    format.color.alpha_size = (unsigned short) value;
+    aglDescribePixelFormat (pixel_format, AGL_DEPTH_SIZE, &value);
+    format.depth_size = (unsigned short) value;
+    aglDescribePixelFormat (pixel_format, AGL_STENCIL_SIZE, &value);
+    format.stencil_size = (unsigned short) value;
+
+    if (thread_info->agl_feature_mask & GLITZ_AGL_FEATURE_MULTISAMPLE_MASK) {
+      aglDescribePixelFormat (pixel_format, AGL_SAMPLE_BUFFERS_ARB, &value);
+      if (value) {
+        aglDescribePixelFormat (pixel_format, AGL_SAMPLES_ARB, &value);
+        format.samples = (unsigned short) (value > 1)? value: 1;
+      } else
+        format.samples = 1;
+    } else
+      format.samples = 1;
+
+    if (thread_info->agl_feature_mask & GLITZ_AGL_FEATURE_PBUFFER_MASK) {
+      if (format.color.red_size && format.color.green_size &&
+          format.color.blue_size && format.color.alpha_size &&
+          format.doublebuffer == 0 && format.stencil_size == 0 &&
+          format.depth_size == 0) {
+        
+        if (thread_info->agl_feature_mask &
+            GLITZ_AGL_FEATURE_PBUFFER_MULTISAMPLE_MASK)
+          format.types.pbuffer = 1;
+        else if (format.samples == 1)
+          format.types.pbuffer = 1;
+        else
+          format.types.pbuffer = 0;
+      } else
+        format.types.pbuffer = 0;
+    } else
+      format.types.pbuffer = 0;
+
+    if (format.color.red_size ||
+        format.color.green_size ||
+        format.color.blue_size ||
+        format.color.alpha_size)
+      _glitz_add_format (thread_info, &format, pixel_format);
+  }
+
+  if (!thread_info->n_formats)
+    return;
+
+  qsort (thread_info->formats, thread_info->n_formats,
+         sizeof (glitz_drawable_format_t), _glitz_agl_format_compare);
+
+  /*
+   * Update AGLPixelFormat list so that it matches the sorted format list.
+   */
+  new_pfs = malloc (sizeof (AGLPixelFormat) * thread_info->n_formats);
+  if (!new_pfs) {
+    thread_info->n_formats = 0;
+    return;
+  }
+  
+  for (i = 0; i < thread_info->n_formats; i++) {
+    new_pfs[i] = thread_info->pixel_formats[thread_info->formats[i].id];
+    thread_info->formats[i].id = i;
+  }
+  
+  free (thread_info->pixel_formats);
+  thread_info->pixel_formats = new_pfs;
+}
+
+glitz_drawable_format_t *
+glitz_agl_find_drawable_format (unsigned long                 mask,
+                                const glitz_drawable_format_t *templ,
+                                int                           count)
+{
+  glitz_agl_thread_info_t *thread_info = glitz_agl_thread_info_get ();
+
+  return glitz_drawable_format_find (thread_info->formats,
+                                     thread_info->n_formats,
+                                     mask, templ, count);
+}
+slim_hidden_def(glitz_agl_find_drawable_format);
diff --git a/src/glitz_agl_info.c b/src/agl/glitz_agl_info.c
index 3a921a6..575c022 100644
--- a/src/glitz_agl_info.c
+++ b/src/agl/glitz_agl_info.c
@@ -1,28 +1,26 @@
 /*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
+ * Copyright © 2004 David Reveman
+ * 
  * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
  *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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.
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
+ * Author: David Reveman <c99drn@cs.umu.se>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -34,9 +32,12 @@
 #include <OpenGL/glext.h>
 
 glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address = {
+
+  /* core */
   (glitz_gl_enable_t) glEnable,
   (glitz_gl_disable_t) glDisable,
   (glitz_gl_get_error_t) glGetError,
+  (glitz_gl_get_string_t) glGetString,
   (glitz_gl_enable_client_state_t) glEnableClientState,
   (glitz_gl_disable_client_state_t) glDisableClientState,
   (glitz_gl_vertex_pointer_t) glVertexPointer,
@@ -91,6 +92,7 @@ glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address = {
   (glitz_gl_copy_tex_sub_image_2d_t) glCopyTexSubImage2D,
   (glitz_gl_get_integer_v_t) glGetIntegerv,
 
+  /* extensions */
   (glitz_gl_blend_color_t) 0,
   (glitz_gl_active_texture_t) 0,
   (glitz_gl_gen_programs_t) 0,
@@ -106,81 +108,9 @@ glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address = {
   (glitz_gl_buffer_sub_data_t) 0,
   (glitz_gl_get_buffer_sub_data_t) 0,
   (glitz_gl_map_buffer_t) 0,
-  (glitz_gl_unmap_buffer_t) 0,
-  
-  1
+  (glitz_gl_unmap_buffer_t) 0
 };
 
-CFBundleRef
-glitz_agl_get_bundle (const char *name)
-{
-  CFBundleRef bundle = 0;
-  FSRefParam ref_param;
-  unsigned char framework_name[256];
-
-  framework_name[0] = strlen (name);
-  strcpy (&framework_name[1], name);
-  
-  memset (&ref_param, 0, sizeof (ref_param));
-
-  if (FindFolder (kSystemDomain,
-                  kFrameworksFolderType,
-                  kDontCreateFolder,
-                  &ref_param.ioVRefNum,
-                  &ref_param.ioDirID) == noErr) {
-    FSRef ref;
-
-    memset (&ref, 0, sizeof (ref));
-
-    ref_param.ioNamePtr = framework_name;
-    ref_param.newRef = &ref;
-
-    if (PBMakeFSRefSync (&ref_param) == noErr) {
-      CFURLRef url;
-
-      url = CFURLCreateFromFSRef (kCFAllocatorDefault, &ref);
-      if (url) {
-        bundle = CFBundleCreate (kCFAllocatorDefault, url);
-        CFRelease (url);
-
-        if (!CFBundleLoadExecutable (bundle)) {
-          CFRelease (bundle);
-          return (CFBundleRef) 0;
-        }
-      }
-    }
-  }
-    
-  return bundle;
-}
-
-void
-glitz_agl_release_bundle (CFBundleRef bundle)
-{
-  if (bundle) {
-    CFBundleUnloadExecutable (bundle);
-    CFRelease (bundle);
-  }
-}
-
-glitz_function_pointer_t
-glitz_agl_get_proc_address (CFBundleRef bundle, const char *name)
-{
-  glitz_function_pointer_t address = NULL;
-  CFStringRef str;
-  
-  if (bundle) {
-    str = CFStringCreateWithCString (kCFAllocatorDefault, name,
-                                     kCFStringEncodingMacRoman);
-
-    address = CFBundleGetFunctionPointerForName (bundle, str);
-
-    CFRelease (str);
-  }
-  
-  return address;
-}
-
 static void
 glitz_agl_thread_info_init (glitz_agl_thread_info_t *thread_info);
 
@@ -244,6 +174,7 @@ glitz_agl_thread_info_get (void)
 
 /* not thread safe */
 static glitz_agl_thread_info_t _thread_info = {
+  0,
   NULL,
   NULL,
   0,
@@ -251,10 +182,7 @@ static glitz_agl_thread_info_t _thread_info = {
   0,
   { 0 },
   0,
-  { 0 },
-  0,
-  0,
-  0,
+  NULL,
   0,
   { 0 }
 };
@@ -280,59 +208,24 @@ glitz_agl_thread_info_get (void)
 static void
 glitz_agl_thread_info_init (glitz_agl_thread_info_t *thread_info)
 {
-  GLint attrib[] = {
-    AGL_RGBA,
-    AGL_NO_RECOVERY,
-    AGL_NONE
-  };
-
   thread_info->formats = NULL;
-  thread_info->format_ids = NULL;
+  thread_info->pixel_formats = (AGLPixelFormat *) 0;
   thread_info->n_formats = 0;
   thread_info->contexts = NULL;
   thread_info->n_contexts = 0;
 
-  glitz_program_map_init (&thread_info->program_map);
-
-  glitz_agl_surface_backend_init (&thread_info->root_context.backend);
+  thread_info->context_stack_size = 1;
+  thread_info->context_stack->surface = NULL;
+  thread_info->context_stack->constraint = GLITZ_NONE;
 
-  memcpy (&thread_info->root_context.backend.gl,
-          &_glitz_agl_gl_proc_address,
-          sizeof (glitz_gl_proc_address_list_t));
-  
-  thread_info->root_context.backend.formats = NULL;
-  thread_info->root_context.backend.n_formats = 0;
-  thread_info->root_context.backend.program_map = NULL;
-  thread_info->root_context.backend.feature_mask = 0;
+  thread_info->root_context = NULL;
 
-  thread_info->agl_feature_mask = thread_info->feature_mask = 0;
-  
-  thread_info->root_context.pixel_format =
-    aglChoosePixelFormat (NULL, 0, attrib);
-  if (thread_info->root_context.pixel_format) {
-    thread_info->root_context.context =
-      aglCreateContext (thread_info->root_context.pixel_format, NULL);
-    if (thread_info->root_context.context) {
+  thread_info->agl_feature_mask = 0;
 
-      aglSetCurrentContext (thread_info->root_context.context);
-  
-      if (glitz_agl_query_extensions (thread_info) == GLITZ_STATUS_SUCCESS) {
-          thread_info->root_context.backend.feature_mask =
-            thread_info->feature_mask;
-        glitz_agl_context_proc_address_lookup (thread_info,
-                                               &thread_info->root_context);
-        glitz_agl_query_formats (thread_info);
-      }
-    }
-  }
-
-  thread_info->root_context.backend.formats = thread_info->formats;
-  thread_info->root_context.backend.n_formats = thread_info->n_formats;
-  thread_info->root_context.backend.program_map = &thread_info->program_map;
+  glitz_program_map_init (&thread_info->program_map);
 
-  thread_info->context_stack_size = 1;
-  thread_info->context_stack->surface = NULL;
-  thread_info->context_stack->constraint = GLITZ_CN_NONE;
+  if (!glitz_agl_query_extensions (thread_info))
+    glitz_agl_query_formats (thread_info);
 }
 
 static void
@@ -340,27 +233,17 @@ glitz_agl_thread_info_fini (glitz_agl_thread_info_t *thread_info)
 {
   int i;
 
-  if (thread_info->root_context.context) {
-    aglSetCurrentContext (thread_info->root_context.context);
-    glitz_program_map_fini (&thread_info->root_context.backend.gl,
-                            &thread_info->program_map);
-    aglSetCurrentContext (NULL);
-  }
-
   for (i = 0; i < thread_info->n_contexts; i++)
     glitz_agl_context_destroy (thread_info, thread_info->contexts[i]);
-
+  
   for (i = 0; i < thread_info->n_formats; i++)
-    aglDestroyPixelFormat (thread_info->format_ids[i]);
-
+    aglDestroyPixelFormat (thread_info->pixel_formats[i]);
+  
   if (thread_info->formats)
     free (thread_info->formats);
   
-  if (thread_info->format_ids)
-    free (thread_info->format_ids);
-
-  if (thread_info->root_context.context)
-    aglDestroyContext (thread_info->root_context.context);
+  if (thread_info->pixel_formats)
+    free (thread_info->pixel_formats);
 }
 
 void
@@ -373,8 +256,7 @@ slim_hidden_def(glitz_agl_init);
 void
 glitz_agl_fini (void)
 {
-  glitz_agl_thread_info_t *info =
-    glitz_agl_thread_info_get ();
+  glitz_agl_thread_info_t *info = glitz_agl_thread_info_get ();
 
   glitz_agl_thread_info_destroy (info);
 }
diff --git a/src/agl/glitz_agl_pbuffer.c b/src/agl/glitz_agl_pbuffer.c
new file mode 100644
index 0000000..5237316
--- /dev/null
+++ b/src/agl/glitz_agl_pbuffer.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../../config.h"
+#endif
+
+#include "glitz_aglint.h"
+
+AGLPbuffer
+glitz_agl_pbuffer_create (glitz_agl_thread_info_t    *thread_info,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask,
+                          int                        *width,
+                          int                        *height)
+{
+  AGLPbuffer pbuffer;
+  glitz_gl_enum_t target;
+  int w, h;
+
+  if (mask & GLITZ_PBUFFER_WIDTH_MASK)
+    w = attributes->width;
+  else
+    w = GLITZ_DEFAULT_PBUFFER_WIDTH;
+
+  if (mask & GLITZ_PBUFFER_HEIGHT_MASK)
+    h = attributes->height;
+  else
+    h = GLITZ_DEFAULT_PBUFFER_HEIGHT;
+
+  if (!POWER_OF_TWO (w) || !POWER_OF_TWO (h)) {
+    if (thread_info->agl_feature_mask &
+        GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK)
+      target = GLITZ_GL_TEXTURE_RECTANGLE;
+    else
+      return (AGLPbuffer) 0;
+  } else
+    target = GLITZ_GL_TEXTURE_2D;
+
+  aglCreatePBuffer (w, h, target, GLITZ_GL_RGBA, 0, &pbuffer);
+
+  *width = w;
+  *height = h;
+
+  return pbuffer;
+}
+
+void 
+glitz_agl_pbuffer_destroy (AGLPbuffer pbuffer)
+{
+  aglDestroyPBuffer (pbuffer);
+}
diff --git a/src/agl/glitz_aglint.h b/src/agl/glitz_aglint.h
new file mode 100644
index 0000000..0127117
--- /dev/null
+++ b/src/agl/glitz_aglint.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifndef GLITZ_GLXINT_H_INCLUDED
+#define GLITZ_GLXINT_H_INCLUDED
+
+#include "glitz.h"
+#include "glitzint.h"
+
+#include "glitz-agl.h"
+
+#include <OpenGL/gl.h>
+#include <Carbon/Carbon.h>
+#include <AGL/agl.h>
+
+#define GLITZ_AGL_FEATURE_PBUFFER_MASK             (1L << 0)
+#define GLITZ_AGL_FEATURE_MULTISAMPLE_MASK         (1L << 1)
+#define GLITZ_AGL_FEATURE_PBUFFER_MULTISAMPLE_MASK (1L << 2)
+#define GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK   (1L << 3)
+
+typedef struct _glitz_agl_drawable glitz_agl_drawable_t;
+
+typedef struct _glitz_agl_context_info_t {
+  glitz_agl_drawable_t *drawable;
+  glitz_surface_t      *surface;
+  glitz_constraint_t   constraint;
+} glitz_agl_context_info_t;
+
+typedef struct _glitz_agl_context_t {
+  AGLContext        context;
+  glitz_format_id_t id;
+  AGLPixelFormat    pixel_format;
+  glitz_bool_t      pbuffer;
+  glitz_backend_t   backend;
+  glitz_gl_int_t    max_viewport_dims[2];
+  glitz_gl_int_t    max_texture_2d_size;
+  glitz_gl_int_t    max_texture_rect_size;
+  glitz_bool_t      initialized;
+} glitz_agl_context_t;
+
+typedef struct _glitz_agl_thread_info_t {
+  int                      drawables;
+  glitz_drawable_format_t  *formats;
+  AGLPixelFormat           *pixel_formats;
+  int                      n_formats;
+  glitz_agl_context_t      **contexts;
+  int                      n_contexts;
+  glitz_agl_context_info_t context_stack[GLITZ_CONTEXT_STACK_SIZE];
+  int                      context_stack_size;
+  AGLContext               root_context;
+  unsigned long            agl_feature_mask;
+  glitz_program_map_t      program_map;
+} glitz_agl_thread_info_t;
+
+struct _glitz_agl_drawable {
+  glitz_drawable_t        base;
+  
+  glitz_agl_thread_info_t *thread_info;
+  glitz_agl_context_t     *context;
+  AGLDrawable             drawable;
+  AGLPbuffer              pbuffer;
+  WindowRef               window;
+};
+
+extern glitz_status_t __internal_linkage
+glitz_agl_query_extensions (glitz_agl_thread_info_t *thread_info);
+
+extern glitz_agl_thread_info_t *__internal_linkage
+glitz_agl_thread_info_get (void);
+
+extern glitz_agl_context_t *__internal_linkage
+glitz_agl_context_get (glitz_agl_thread_info_t *thread_info,
+                       glitz_drawable_format_t *format);
+
+extern void __internal_linkage
+glitz_agl_context_destroy (glitz_agl_thread_info_t *thread_info,
+                           glitz_agl_context_t     *context);
+
+extern void __internal_linkage
+glitz_agl_query_formats (glitz_agl_thread_info_t *thread_info);
+
+extern AGLPbuffer __internal_linkage
+glitz_agl_pbuffer_create (glitz_agl_thread_info_t    *thread_info,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask,
+                          int                        *width,
+                          int                        *height);
+
+extern void __internal_linkage
+glitz_agl_pbuffer_destroy (AGLPbuffer pbuffer);
+
+extern glitz_drawable_t *__internal_linkage
+glitz_agl_create_pbuffer (void                       *abstract_templ,
+                          glitz_drawable_format_t    *format,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask);
+
+extern void __internal_linkage
+glitz_agl_push_current (void               *abstract_drawable,
+                        glitz_surface_t    *surface,
+                        glitz_constraint_t constraint);
+
+extern glitz_surface_t *__internal_linkage
+glitz_agl_pop_current (void *abstract_drawable);
+
+extern glitz_status_t __internal_linkage
+glitz_agl_make_current_read (void *abstract_surface);
+
+extern void __internal_linkage
+glitz_agl_destroy (void *abstract_drawable);
+
+extern void __internal_linkage
+glitz_agl_swap_buffers (void *abstract_drawable);
+
+/* Avoid unnecessary PLT entries.  */
+
+slim_hidden_proto(glitz_agl_init)
+slim_hidden_proto(glitz_agl_fini)
+slim_hidden_proto(glitz_agl_find_drawable_format)
+slim_hidden_proto(glitz_agl_create_drawable_for_window)
+slim_hidden_proto(glitz_agl_create_pbuffer_drawable)
+
+#endif /* GLITZ_GLXINT_H_INCLUDED */
diff --git a/src/glitz-agl.h b/src/glitz-agl.h
deleted file mode 100644
index b89409d..0000000
--- a/src/glitz-agl.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifndef GLITZ_AGL_H_INCLUDED
-#define GLITZ_AGL_H_INCLUDED
-
-#include <glitz.h>
-
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
-#include <Carbon/Carbon.h>
-
-/* glitz_agl_info.c */
-
-void
-glitz_agl_init (void);
-
-void
-glitz_agl_fini (void);
-  
-  
-/* glitz_agl_format.c */
-
-glitz_format_t *
-glitz_agl_find_format (unsigned long mask,
-                       const glitz_format_t *templ,
-                       int count);
-  
-glitz_format_t *
-glitz_agl_find_standard_format (glitz_format_name_t format_name);
-
-  
-/* glitz_agl_surface.c */
-
-glitz_surface_t *
-glitz_agl_surface_create (glitz_format_t *format,
-                          int width,
-                          int height);
-
-glitz_surface_t *
-glitz_agl_surface_create_for_window (glitz_format_t *format,
-                                     WindowRef window,
-                                     int width,
-                                     int height);
-
-#if defined(__cplusplus) || defined(c_plusplus)
-}
-#endif
-
-#endif /* GLITZ_AGL_H_INCLUDED */
diff --git a/src/glitz-glx.h b/src/glitz-glx.h
deleted file mode 100644
index e4b9aad..0000000
--- a/src/glitz-glx.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifndef GLITZ_GLX_H_INCLUDED
-#define GLITZ_GLX_H_INCLUDED
-
-#include <glitz.h>
-
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-
-/* glitz_glx_info.c */
-
-void
-glitz_glx_init (const char *gl_library);
-
-void
-glitz_glx_fini (void);
-  
-  
-/* glitz_glx_format.c */
-
-glitz_format_t *
-glitz_glx_find_format (Display *display,
-                       int screen,
-                       unsigned long mask,
-                       const glitz_format_t *templ,
-                       int count);
-  
-glitz_format_t *
-glitz_glx_find_standard_format (Display *display,
-                                int screen,
-                                glitz_format_name_t format_name);
-
-XVisualInfo *
-glitz_glx_get_visual_info_from_format (Display *display,
-                                       int screen,
-                                       glitz_format_t *format);
-  
-
-/* glitz_glx_surface.c */
-
-glitz_surface_t *
-glitz_glx_surface_create (Display *display,
-                          int screen,
-                          glitz_format_t *format,
-                          int width,
-                          int height);
-
-glitz_surface_t *
-glitz_glx_surface_create_for_window (Display *display,
-                                     int screen,
-                                     glitz_format_t *format,
-                                     Window window,
-                                     int width,
-                                     int height);
-
-#if defined(__cplusplus) || defined(c_plusplus)
-}
-#endif
-
-#endif /* GLITZ_GLX_H_INCLUDED */
diff --git a/src/glitz.c b/src/glitz.c
index 423adc3..39620a5 100644
--- a/src/glitz.c
+++ b/src/glitz.c
@@ -61,9 +61,6 @@ glitz_composite (glitz_operator_t op,
                  int width,
                  int height)
 {
-  glitz_gl_proc_address_list_t *gl = &dst->backend->gl;
-  glitz_surface_t *intermediate = NULL;
-  glitz_bounding_box_t rect;
   glitz_composite_op_t comp_op;
   int i, passes, texture_nr = -1;
   glitz_texture_t *stexture, *mtexture;
@@ -72,6 +69,9 @@ glitz_composite (glitz_operator_t op,
   glitz_gl_enum_t primitive;
   glitz_gl_int_t first;
   glitz_gl_sizei_t count;
+  glitz_box_t rect;
+
+  GLITZ_GL_SURFACE (dst);
 
   if (width <= 0 || height <= 0)
     return;
@@ -84,64 +84,6 @@ glitz_composite (glitz_operator_t op,
 
   src = comp_op.src;
   mask = comp_op.mask;
-  
-  if (comp_op.type == GLITZ_COMBINE_TYPE_INTERMEDIATE) {
-    glitz_format_t templ;
-    glitz_format_t *format;
-    unsigned long templ_mask;
-    
-    templ.red_size = src->format->red_size;
-    templ.green_size = src->format->green_size;
-    templ.blue_size = src->format->blue_size;
-    templ.alpha_size = MAX (src->format->alpha_size, mask->format->alpha_size);
-    templ.draw.offscreen = 1;
-    
-    templ_mask = GLITZ_FORMAT_RED_SIZE_MASK | GLITZ_FORMAT_GREEN_SIZE_MASK |
-      GLITZ_FORMAT_BLUE_SIZE_MASK | GLITZ_FORMAT_ALPHA_SIZE_MASK |
-      GLITZ_FORMAT_DRAW_OFFSCREEN_MASK;
-    
-    format = glitz_surface_find_similar_format (dst, templ_mask, &templ, 0);
-    if (!format) {
-      glitz_surface_status_add (dst, GLITZ_STATUS_NOT_SUPPORTED_MASK);
-      return;
-    }
-    
-    intermediate = glitz_surface_create_similar (dst, format, width, height);  
-    if (!intermediate) {
-      glitz_surface_status_add (dst, GLITZ_STATUS_NOT_SUPPORTED_MASK);
-      return;
-    }
-    
-    glitz_composite (GLITZ_OPERATOR_SRC,
-                     mask, NULL, intermediate,
-                     x_mask, y_mask,
-                     0, 0,
-                     0, 0,
-                     width,
-                     height);
-
-    glitz_composite (GLITZ_OPERATOR_IN,
-                     src, NULL, intermediate,
-                     x_src, y_src,
-                     0, 0,
-                     0, 0,
-                     width,
-                     height);
-    
-    src = intermediate;
-    mask = NULL;
-    x_src = y_src = 0;
-
-    glitz_composite_op_init (&comp_op, op, src, mask, dst);
-    if (comp_op.type == GLITZ_COMBINE_TYPE_NA) {
-      glitz_surface_status_add (dst, GLITZ_STATUS_NOT_SUPPORTED_MASK);
-      glitz_surface_destroy (intermediate);
-      return;
-    }
-
-    src = comp_op.src;
-    mask = comp_op.mask;
-  }
 
   if (src) {
     stexture = glitz_surface_get_texture (src, 0);
@@ -157,7 +99,7 @@ glitz_composite (glitz_operator_t op,
   } else
     mtexture = NULL;
 
-  if (!glitz_surface_push_current (dst, GLITZ_CN_SURFACE_DRAWABLE_CURRENT)) {
+  if (!glitz_surface_push_current (dst, GLITZ_DRAWABLE_CURRENT)) {
     glitz_surface_status_add (dst, GLITZ_STATUS_NOT_SUPPORTED_MASK);
     glitz_surface_pop_current (dst);
     return;
@@ -202,7 +144,7 @@ glitz_composite (glitz_operator_t op,
       else
         glitz_texture_ensure_wrap (gl, mtexture, GLITZ_GL_REPEAT);
     } else {
-      if ((!(dst->backend->feature_mask &
+      if ((!(dst->drawable->backend->feature_mask &
              GLITZ_FEATURE_TEXTURE_BORDER_CLAMP_MASK)) ||
           SURFACE_PAD (mask))
         glitz_texture_ensure_wrap (gl, mtexture, GLITZ_GL_CLAMP_TO_EDGE);
@@ -235,7 +177,7 @@ glitz_composite (glitz_operator_t op,
       gl->load_matrix_f (SURFACE_EYE_COORDS (src)?
                          src->transform->m: src->transform->t);
       gl->matrix_mode (GLITZ_GL_MODELVIEW);
-      
+
       if (SURFACE_LINEAR_TRANSFORM_FILTER (src))
         glitz_texture_ensure_filter (gl, stexture, GLITZ_GL_LINEAR);
       else
@@ -249,7 +191,7 @@ glitz_composite (glitz_operator_t op,
       else
         glitz_texture_ensure_wrap (gl, stexture, GLITZ_GL_REPEAT);
     } else {
-      if ((!(dst->backend->feature_mask &
+      if ((!(dst->drawable->backend->feature_mask &
              GLITZ_FEATURE_TEXTURE_BORDER_CLAMP_MASK)) ||
           SURFACE_PAD (src))
         glitz_texture_ensure_wrap (gl, stexture, GLITZ_GL_CLAMP_TO_EDGE);
@@ -258,8 +200,8 @@ glitz_composite (glitz_operator_t op,
     }
   }
 
-  gl->scissor (rect.x1,
-               dst->height - rect.y2,
+  gl->scissor (rect.x1 + dst->x,
+               dst->attached->height - dst->y - rect.y2,
                width, height);
 
   gl->push_matrix ();
@@ -388,13 +330,12 @@ glitz_composite (glitz_operator_t op,
     if (i > 0)
       gl->active_texture (textures[i - 1].unit);
   }
-  
-  glitz_surface_dirty (dst, &rect);
+
+  glitz_surface_damage (dst, &rect,
+                        GLITZ_DAMAGE_TEXTURE_MASK |
+                        GLITZ_DAMAGE_SOLID_MASK);
   
   glitz_surface_pop_current (dst);
-  
-  if (intermediate)
-    glitz_surface_destroy (intermediate);
 }
 
 void
@@ -407,8 +348,9 @@ glitz_copy_area (glitz_surface_t *src,
                  int x_dst,
                  int y_dst)
 {
-  glitz_gl_proc_address_list_t *gl;
-  int status;
+  glitz_status_t status;
+
+  GLITZ_GL_SURFACE (dst);
   
   if (x_src < 0) {
     x_dst -= x_src;
@@ -443,35 +385,44 @@ glitz_copy_area (glitz_surface_t *src,
   if (width <= 0 || height <= 0)
     return;
 
-  gl = &dst->backend->gl;
-
-  status = 0;
-  if (glitz_surface_push_current (dst, GLITZ_CN_SURFACE_DRAWABLE_CURRENT)) {
-    glitz_bounding_box_t box;
+  status = GLITZ_STATUS_NOT_SUPPORTED;
+  if (glitz_surface_push_current (dst, GLITZ_DRAWABLE_CURRENT)) {
+    glitz_box_t box;
     
-    if (src != dst)
+    if (src->attached == dst->attached) {
+      if (REGION_NOTEMPTY (&src->drawable_damage)) {
+        glitz_surface_push_current (src, GLITZ_DRAWABLE_CURRENT);
+        glitz_surface_pop_current (src);
+      }
+      status = GLITZ_STATUS_SUCCESS;
+    } else
       status = glitz_surface_make_current_read (src);
-    else
-      status = 1;
 
     box.x1 = x_dst;
     box.y1 = y_dst;
     box.x2 = box.x1 + width;
     box.y2 = box.y1 + height;
 
-    if (status) {
-      if (src->format->doublebuffer)
-        gl->read_buffer (src->read_buffer);
+    if (!status) {
+      gl->read_buffer (src->buffer);
+      gl->draw_buffer (dst->buffer);
       
       glitz_set_operator (gl, GLITZ_OPERATOR_SRC);
       
-      gl->scissor (0, 0, dst->width, dst->height);
+      gl->disable (GLITZ_GL_SCISSOR_TEST);
       
-      glitz_set_raster_pos (gl, x_dst, dst->height - (y_dst + height));
-      gl->copy_pixels (x_src, src->height - (y_src + height),
+      glitz_set_raster_pos (gl,
+                            x_dst + dst->x,
+                            dst->attached->height - (y_dst + dst->y + height));
+      gl->copy_pixels (x_src + src->x,
+                       src->attached->height - (y_src + src->y + height),
                        width, height, GLITZ_GL_COLOR);
+
+      gl->enable (GLITZ_GL_SCISSOR_TEST);
     } else {
-      glitz_texture_t *texture = glitz_surface_get_texture (src, 0);
+      glitz_texture_t *texture;
+
+      texture = glitz_surface_get_texture (src, 0);
       if (texture) {
         glitz_texture_bind (gl, texture);
 
@@ -489,8 +440,8 @@ glitz_copy_area (glitz_surface_t *src,
 
         glitz_set_operator (gl, GLITZ_OPERATOR_SRC);
 
-        gl->scissor (box.x1,
-                     dst->height - box.y2,
+        gl->scissor (box.x1 + dst->x,
+                     dst->attached->height - dst->y - box.y2,
                      width, height);
         
         glitz_geometry_enable_default (gl, dst, &box);
@@ -501,57 +452,56 @@ glitz_copy_area (glitz_surface_t *src,
       }
     }
     
-    glitz_surface_dirty (dst, &box);
+    glitz_surface_damage (dst, &box,
+                          GLITZ_DAMAGE_TEXTURE_MASK |
+                          GLITZ_DAMAGE_SOLID_MASK);
 
-    status = 1;
+    status = GLITZ_STATUS_SUCCESS;
   }
 
   glitz_surface_pop_current (dst);
 
-  if (!status) {
-    if (glitz_surface_push_current (src, GLITZ_CN_SURFACE_DRAWABLE_CURRENT)) {
+  if (status) {
+    if (glitz_surface_push_current (src, GLITZ_DRAWABLE_CURRENT)) {
       glitz_texture_t *texture;
 
-      if (src->format->doublebuffer)
-        gl->read_buffer (src->read_buffer);
-
-      gl->scissor (0, 0, src->width, src->height);
+      gl->read_buffer (src->buffer);
 
       texture = glitz_surface_get_texture (dst, 1);
       if (texture) {
-        glitz_texture_copy_surface (texture, src,
-                                    x_src, y_src, width, height, x_dst, y_dst);
-        status = 1;
+        glitz_box_t box;
+
+        gl->disable (GLITZ_GL_SCISSOR_TEST);
+
+        glitz_texture_bind (gl, texture);
+
+        glitz_texture_copy_drawable (gl,
+                                     texture,
+                                     src->attached,
+                                     x_src + src->x,
+                                     y_src + src->y,
+                                     width, height,
+                                     x_dst, y_dst);
+
+        glitz_texture_unbind (gl, texture);
+
+        gl->enable (GLITZ_GL_SCISSOR_TEST);
+
+        box.x1 = x_dst;
+        box.y1 = y_dst;
+        box.x2 = box.x1 + width;
+        box.y2 = box.y1 + height;
+
+        glitz_surface_damage (dst, &box,
+                              GLITZ_DAMAGE_DRAWABLE_MASK |
+                              GLITZ_DAMAGE_SOLID_MASK);
+        
+        status = GLITZ_STATUS_SUCCESS;
       }
     }
     glitz_surface_pop_current (src);
   }
 
-  if (!status) {
-    static glitz_pixel_format_t pf = {
-      {
-        32,
-        0xff000000,
-        0x00ff0000,
-        0x0000ff00,
-        0x000000ff
-      },
-      0, 0, 0,
-      GLITZ_PIXEL_SCANLINE_ORDER_BOTTOM_UP
-    };
-    glitz_buffer_t *buffer =
-      glitz_pixel_buffer_create (src,
-                                 NULL,
-                                 width * height * 4,
-                                 GLITZ_BUFFER_HINT_STATIC_COPY);
-    if (!buffer) {
-      glitz_surface_status_add (dst, GLITZ_STATUS_NO_MEMORY_MASK);
-      return;
-    }
-
-    glitz_get_pixels (src, x_src, y_src, width, height, &pf, buffer);
-    glitz_set_pixels (dst, x_dst, y_dst, width, height, &pf, buffer);
-    
-    glitz_buffer_destroy (buffer);
-  }
+  if (status)
+    glitz_surface_status_add (dst, glitz_status_to_status_mask (status));
 }
diff --git a/src/glitz.h b/src/glitz.h
index e9ddecb..1425125 100644
--- a/src/glitz.h
+++ b/src/glitz.h
@@ -36,10 +36,9 @@
 #  endif
 #endif
 
-/* NOTE: Must be manually synchronized with GLITZ_VERSION in configure.in */
-#define GLITZ_MAJOR 0
-#define GLITZ_MINOR 2
-#define GLITZ_REVISION 3
+#define GLITZ_MAJOR    0
+#define GLITZ_MINOR    3
+#define GLITZ_REVISION 0
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -53,7 +52,7 @@ typedef double glitz_double_t;
 typedef int glitz_fixed16_16_t;
 
 typedef struct _glitz_rectangle_t {
-  short x, y;
+  short          x, y;
   unsigned short width, height;
 } glitz_rectangle_t;
 
@@ -90,8 +89,7 @@ typedef enum {
   GLITZ_OPERATOR_ATOP,
   GLITZ_OPERATOR_ATOP_REVERSE,
   GLITZ_OPERATOR_XOR,
-  GLITZ_OPERATOR_ADD,
-  GLITZ_OPERATOR_SATURATE
+  GLITZ_OPERATOR_ADD
 } glitz_operator_t;
 
 #define GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK        (1L <<  0)
@@ -99,16 +97,16 @@ typedef enum {
 #define GLITZ_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK  (1L <<  2)
 #define GLITZ_FEATURE_TEXTURE_BORDER_CLAMP_MASK     (1L <<  3)
 #define GLITZ_FEATURE_MULTISAMPLE_MASK              (1L <<  4)
-#define GLITZ_FEATURE_OFFSCREEN_MULTISAMPLE_MASK    (1L <<  5)
-#define GLITZ_FEATURE_MULTISAMPLE_FILTER_HINT_MASK  (1L <<  6)
-#define GLITZ_FEATURE_MULTITEXTURE_MASK             (1L <<  7)
-#define GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK      (1L <<  8)
-#define GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK         (1L <<  9)
-#define GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK         (1L << 10)
-#define GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK     (1L << 11)
-#define GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK      (1L << 12)
-#define GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK  (1L << 13)
-#define GLITZ_FEATURE_BLEND_COLOR_MASK              (1L << 14)
+#define GLITZ_FEATURE_MULTISAMPLE_FILTER_HINT_MASK  (1L <<  5)
+#define GLITZ_FEATURE_MULTITEXTURE_MASK             (1L <<  6)
+#define GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK      (1L <<  7)
+#define GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK         (1L <<  8)
+#define GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK         (1L <<  9)
+#define GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK     (1L << 10)
+#define GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK      (1L << 11)
+#define GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK  (1L << 12)
+#define GLITZ_FEATURE_BLEND_COLOR_MASK              (1L << 13)
+#define GLITZ_FEATURE_PACKED_PIXELS_MASK            (1L << 14)
 
 typedef enum {
   GLITZ_STANDARD_ARGB32,
@@ -117,69 +115,155 @@ typedef enum {
   GLITZ_STANDARD_A1
 } glitz_format_name_t;
   
-#define GLITZ_FORMAT_ID_MASK                  (1L <<  0)
-#define GLITZ_FORMAT_RED_SIZE_MASK            (1L <<  6)
-#define GLITZ_FORMAT_GREEN_SIZE_MASK          (1L <<  7)
-#define GLITZ_FORMAT_BLUE_SIZE_MASK           (1L <<  8)
-#define GLITZ_FORMAT_ALPHA_SIZE_MASK          (1L <<  9)
-#define GLITZ_FORMAT_DEPTH_SIZE_MASK          (1L << 10)
-#define GLITZ_FORMAT_STENCIL_SIZE_MASK        (1L << 11)
-#define GLITZ_FORMAT_DOUBLEBUFFER_MASK        (1L << 12)
-#define GLITZ_FORMAT_READ_ONSCREEN_MASK       (1L << 13)
-#define GLITZ_FORMAT_READ_OFFSCREEN_MASK      (1L << 14)
-#define GLITZ_FORMAT_DRAW_ONSCREEN_MASK       (1L << 15)
-#define GLITZ_FORMAT_DRAW_OFFSCREEN_MASK      (1L << 16)
-#define GLITZ_FORMAT_MULTISAMPLE_MASK         (1L << 17)
-#define GLITZ_FORMAT_MULTISAMPLE_SAMPLES_MASK (1L << 18)
-
-typedef unsigned long int glitz_format_id_t;
-
-typedef struct _glitz_drawable_type_t {
-  glitz_bool_t onscreen;
-  glitz_bool_t offscreen;
-} glitz_drawable_type_t;
-
-typedef struct _glitz_multisample_format_t {
-  glitz_bool_t supported;
-  unsigned short samples;
-} glitz_multisample_format_t;
+#define GLITZ_FORMAT_ID_MASK         (1L <<  0)
+#define GLITZ_FORMAT_RED_SIZE_MASK   (1L <<  1)
+#define GLITZ_FORMAT_GREEN_SIZE_MASK (1L <<  2)
+#define GLITZ_FORMAT_BLUE_SIZE_MASK  (1L <<  3)
+#define GLITZ_FORMAT_ALPHA_SIZE_MASK (1L <<  4)
 
-typedef struct _glitz_format_t {
-  glitz_format_id_t id;
-  
+typedef unsigned long glitz_format_id_t;
+
+typedef struct _glitz_color_format_t {
   unsigned short red_size;
   unsigned short green_size;
   unsigned short blue_size;
   unsigned short alpha_size;
-  unsigned short depth_size;
-  unsigned short stencil_size;
-  
-  glitz_bool_t doublebuffer;
-  glitz_drawable_type_t read;
-  glitz_drawable_type_t draw;
-  glitz_multisample_format_t multisample;
-} glitz_format_t;
-
-typedef struct _glitz_surface glitz_surface_t;
-typedef struct _glitz_buffer glitz_buffer_t;
+} glitz_color_format_t;
 
   
 /* glitz_status.c */
   
 typedef enum {
-    GLITZ_STATUS_SUCCESS = 0,
-    GLITZ_STATUS_NO_MEMORY,
-    GLITZ_STATUS_BAD_COORDINATE,
-    GLITZ_STATUS_NOT_SUPPORTED,
-    GLITZ_STATUS_CONTENT_DESTROYED
+  GLITZ_STATUS_SUCCESS = 0,
+  GLITZ_STATUS_NO_MEMORY,
+  GLITZ_STATUS_BAD_COORDINATE,
+  GLITZ_STATUS_NOT_SUPPORTED,
+  GLITZ_STATUS_CONTENT_DESTROYED
 } glitz_status_t;
 
 const char *
 glitz_status_string (glitz_status_t status);
 
+
+/* glitz_drawable.c */
+
+typedef struct _glitz_drawable glitz_drawable_t;
+
+typedef enum {
+  GLITZ_DRAWABLE_BUFFER_FRONT_COLOR,
+  GLITZ_DRAWABLE_BUFFER_BACK_COLOR
+} glitz_drawable_buffer_t;
+    
+#define GLITZ_FORMAT_DEPTH_SIZE_MASK   (1L <<  5)
+#define GLITZ_FORMAT_STENCIL_SIZE_MASK (1L <<  6)
+#define GLITZ_FORMAT_DOUBLEBUFFER_MASK (1L <<  7)
+#define GLITZ_FORMAT_SAMPLES_MASK      (1L <<  8)
+#define GLITZ_FORMAT_WINDOW_MASK       (1L <<  9)
+#define GLITZ_FORMAT_PBUFFER_MASK      (1L << 10)
+    
+typedef struct _glitz_drawable_types_t {
+  glitz_bool_t window;
+  glitz_bool_t pbuffer;
+} glitz_drawable_types_t;
+
+typedef struct _glitz_drawable_format_t {
+  glitz_format_id_t      id;
+  glitz_color_format_t   color;
+  unsigned short         depth_size;
+  unsigned short         stencil_size;
+  unsigned short         samples;
+  glitz_bool_t           doublebuffer;
+  glitz_drawable_types_t types;
+} glitz_drawable_format_t;
+
+#define GLITZ_PBUFFER_WIDTH_MASK  (1L << 0)
+#define GLITZ_PBUFFER_HEIGHT_MASK (1L << 1)
+
+typedef struct _glitz_pbuffer_attributes_t {
+  unsigned int width;
+  unsigned int height;
+} glitz_pbuffer_attributes_t;
+    
+glitz_drawable_format_t *
+glitz_find_similar_drawable_format (glitz_drawable_t              *other,
+                                    unsigned long                 mask,
+                                    const glitz_drawable_format_t *templ,
+                                    int                           count);
+    
+glitz_drawable_t *
+glitz_create_pbuffer_drawable (glitz_drawable_t           *other,
+                               glitz_drawable_format_t    *format,
+                               glitz_pbuffer_attributes_t *attributes,
+                               unsigned long              mask);
+
+void
+glitz_drawable_destroy (glitz_drawable_t *drawable);
+
+void
+glitz_drawable_reference (glitz_drawable_t *drawable);
+
+void
+glitz_drawable_update_size (glitz_drawable_t *drawable,
+                            unsigned int     width,
+                            unsigned int     height);
+
+unsigned int
+glitz_drawable_get_width (glitz_drawable_t *drawable);
+
+unsigned int
+glitz_drawable_get_height (glitz_drawable_t *drawable);
+
+void
+glitz_drawable_swap_buffers (glitz_drawable_t *drawable);
+
+void
+glitz_drawable_flush (glitz_drawable_t *drawable);
+
+void
+glitz_drawable_finish (glitz_drawable_t *drawable);
+
+unsigned long
+glitz_drawable_get_features (glitz_drawable_t *drawable);
+
+glitz_drawable_format_t *
+glitz_drawable_get_format (glitz_drawable_t *drawable);
+
   
+/* glitz_format.c */
+
+#define GLITZ_FORMAT_TYPE_MASK (1L << 5)
+
+typedef enum {
+  GLITZ_FORMAT_TYPE_COLOR
+} glitz_format_type_t;
+    
+typedef struct _glitz_format_t {
+  glitz_format_id_t    id;
+  glitz_format_type_t  type;
+  glitz_color_format_t color;
+} glitz_format_t;
+
+glitz_format_t *
+glitz_find_standard_format (glitz_drawable_t    *drawable,
+                            glitz_format_name_t format_name);
+
+glitz_format_t *
+glitz_find_format (glitz_drawable_t     *drawable,
+                   unsigned long        mask,
+                   const glitz_format_t *templ,
+                   int                  count);
+
+
 /* glitz_surface.c */
 
+typedef struct _glitz_surface glitz_surface_t;
+  
+glitz_surface_t *
+glitz_surface_create (glitz_drawable_t *drawable,
+                      glitz_format_t   *format,
+                      unsigned int     width,
+                      unsigned int     height);
+
 void
 glitz_surface_destroy (glitz_surface_t *surface);
 
@@ -187,7 +271,26 @@ void
 glitz_surface_reference (glitz_surface_t *surface);
 
 void
-glitz_surface_set_transform (glitz_surface_t *surface,
+glitz_surface_attach (glitz_surface_t         *surface,
+                      glitz_drawable_t        *drawable,
+                      glitz_drawable_buffer_t buffer,
+                      int                     x,
+                      int                     y);
+
+void
+glitz_surface_detach (glitz_surface_t *surface);
+
+void
+glitz_surface_flush (glitz_surface_t *surface);
+
+glitz_drawable_t *
+glitz_surface_get_drawable (glitz_surface_t *surface);
+
+glitz_drawable_t *
+glitz_surface_get_attached_drawable (glitz_surface_t *surface);
+
+void
+glitz_surface_set_transform (glitz_surface_t   *surface,
                              glitz_transform_t *transform);
 
 typedef enum {
@@ -199,91 +302,56 @@ typedef enum {
 
 void
 glitz_surface_set_fill (glitz_surface_t *surface,
-                        glitz_fill_t fill);
+                        glitz_fill_t    fill);
 
 void
 glitz_surface_set_component_alpha (glitz_surface_t *surface,
-                                   glitz_bool_t component_alpha);
+                                   glitz_bool_t    component_alpha);
 
 void
-glitz_surface_set_filter (glitz_surface_t *surface,
-                          glitz_filter_t filter,
+glitz_surface_set_filter (glitz_surface_t    *surface,
+                          glitz_filter_t     filter,
                           glitz_fixed16_16_t *params,
-                          int n_params);  
-
-typedef enum {
-  GLITZ_COLOR_BUFFER_FRONT,
-  GLITZ_COLOR_BUFFER_BACK
-} glitz_color_buffer_t;
-
-void
-glitz_surface_set_read_color_buffer (glitz_surface_t *surface,
-                                     glitz_color_buffer_t buffer);
+                          int                n_params);
 
 void
-glitz_surface_set_draw_color_buffer (glitz_surface_t *surface,
-                                     glitz_color_buffer_t buffer);
-  
-void
-glitz_surface_swap_buffers (glitz_surface_t *surface);
-
-void
-glitz_surface_flush (glitz_surface_t *surface);
+glitz_surface_set_dither (glitz_surface_t *surface,
+                          glitz_bool_t    dither);
 
-void
-glitz_surface_finish (glitz_surface_t *surface);
-
-int
+unsigned int
 glitz_surface_get_width (glitz_surface_t *surface);
 
-int
+unsigned int
 glitz_surface_get_height (glitz_surface_t *surface);
 
 glitz_status_t
 glitz_surface_get_status (glitz_surface_t *surface);
 
-unsigned long
-glitz_surface_get_features (glitz_surface_t *surface);
-
 glitz_format_t *
 glitz_surface_get_format (glitz_surface_t *surface);
 
-glitz_format_t *
-glitz_surface_find_similar_standard_format (glitz_surface_t *surface,
-                                            glitz_format_name_t format_name);
-
-glitz_format_t *
-glitz_surface_find_similar_format (glitz_surface_t *surface,
-                                   unsigned long mask,
-                                   const glitz_format_t *templ,
-                                   int count);
-
-glitz_surface_t *
-glitz_surface_create_similar (glitz_surface_t *templ,
-                              glitz_format_t *format,
-                              int width,
-                              int height);
-
   
 /* glitz_rect.c */
 
 void
-glitz_set_rectangle (glitz_surface_t *dst,
+glitz_set_rectangle (glitz_surface_t     *dst,
                      const glitz_color_t *color,
-                     int x,
-                     int y,
-                     unsigned int width,
-                     unsigned int height);
+                     int                 x,
+                     int                 y,
+                     unsigned int        width,
+                     unsigned int        height);
   
 void
-glitz_set_rectangles (glitz_surface_t *dst,
-                      const glitz_color_t *color,
+glitz_set_rectangles (glitz_surface_t         *dst,
+                      const glitz_color_t     *color,
                       const glitz_rectangle_t *rects,
-                      int n_rects);
+                      int                     n_rects);
 
 
 /* glitz_buffer.c */
-  
+
+typedef struct _glitz_buffer glitz_buffer_t;
+    
 typedef enum {
   GLITZ_BUFFER_HINT_STREAM_DRAW,
   GLITZ_BUFFER_HINT_STREAM_READ,
@@ -303,15 +371,15 @@ typedef enum {
 } glitz_buffer_access_t;
 
 glitz_buffer_t *
-glitz_geometry_buffer_create (glitz_surface_t *surface,
-                              void *data,
-                              unsigned int size,
+glitz_geometry_buffer_create (glitz_drawable_t    *drawable,
+                              void                *data,
+                              unsigned int        size,
                               glitz_buffer_hint_t hint);
 
 glitz_buffer_t *
-glitz_pixel_buffer_create (glitz_surface_t *surface,
-                           void *data,
-                           unsigned int size,
+glitz_pixel_buffer_create (glitz_drawable_t    *drawable,
+                           void                *data,
+                           unsigned int        size,
                            glitz_buffer_hint_t hint);
 
 glitz_buffer_t *
@@ -325,18 +393,18 @@ glitz_buffer_reference (glitz_buffer_t *buffer);
 
 void
 glitz_buffer_set_data (glitz_buffer_t *buffer,
-                       int offset,
-                       unsigned int size,
-                       const void *data);
+                       int            offset,
+                       unsigned int   size,
+                       const void     *data);
 
 void
 glitz_buffer_get_data (glitz_buffer_t *buffer,
-                       int offset,
-                       unsigned int size,
-                       void *data);
+                       int            offset,
+                       unsigned int   size,
+                       void           *data);
        
 void *
-glitz_buffer_map (glitz_buffer_t *buffer,
+glitz_buffer_map (glitz_buffer_t        *buffer,
                   glitz_buffer_access_t access);
   
 glitz_status_t
@@ -351,7 +419,7 @@ typedef enum {
 } glitz_pixel_scanline_order_t;
 
 typedef struct _glitz_pixel_masks {
-  int bpp;
+  int           bpp;
   unsigned long alpha_mask;
   unsigned long red_mask;
   unsigned long green_mask;
@@ -359,30 +427,30 @@ typedef struct _glitz_pixel_masks {
 } glitz_pixel_masks_t;
 
 typedef struct _glitz_pixel_format {
-  glitz_pixel_masks_t masks;
-  int xoffset;
-  int skip_lines;
-  int bytes_per_line;
+  glitz_pixel_masks_t          masks;
+  int                          xoffset;
+  int                          skip_lines;
+  int                          bytes_per_line;
   glitz_pixel_scanline_order_t scanline_order;
 } glitz_pixel_format_t;
 
 void
-glitz_set_pixels (glitz_surface_t *dst,
-                  int x_dst,
-                  int y_dst,
-                  int width,
-                  int height,
+glitz_set_pixels (glitz_surface_t      *dst,
+                  int                  x_dst,
+                  int                  y_dst,
+                  int                  width,
+                  int                  height,
                   glitz_pixel_format_t *format,
-                  glitz_buffer_t *buffer);                
+                  glitz_buffer_t       *buffer);                
 
 void
-glitz_get_pixels (glitz_surface_t *src,
-                  int x_src,
-                  int y_src,
-                  int width,
-                  int height,
+glitz_get_pixels (glitz_surface_t      *src,
+                  int                  x_src,
+                  int                  y_src,
+                  int                  width,
+                  int                  height,
                   glitz_pixel_format_t *format,
-                  glitz_buffer_t *buffer);
+                  glitz_buffer_t       *buffer);
   
   
 /* glitz_geometry.c */
@@ -400,6 +468,10 @@ typedef enum {
 } glitz_geometry_edge_hint_t;
 
 typedef enum {
+  GLITZ_GEOMETRY_PRIMITIVE_POINTS,
+  GLITZ_GEOMETRY_PRIMITIVE_LINES,
+  GLITZ_GEOMETRY_PRIMITIVE_LINE_STRIP,
+  GLITZ_GEOMETRY_PRIMITIVE_LINE_LOOP,
   GLITZ_GEOMETRY_PRIMITIVE_TRIANGLES,
   GLITZ_GEOMETRY_PRIMITIVE_TRIANGLE_STRIP,
   GLITZ_GEOMETRY_PRIMITIVE_TRIANGLE_FAN,
@@ -416,47 +488,47 @@ typedef enum {
 } glitz_data_type_t;
 
 typedef struct _glitz_geometry_format {
-  glitz_geometry_mode_t mode;
+  glitz_geometry_mode_t      mode;
   glitz_geometry_edge_hint_t edge_hint;
   glitz_geometry_primitive_t primitive;
-  glitz_data_type_t type;
-  int first;
-  unsigned int count;
+  glitz_data_type_t          type;
+  int                        first;
+  unsigned int               count;
 } glitz_geometry_format_t;
 
 void
-glitz_set_geometry (glitz_surface_t *dst,
-                    int x_dst,
-                    int y_dst,
+glitz_set_geometry (glitz_surface_t         *dst,
+                    glitz_fixed16_16_t      x_dst,
+                    glitz_fixed16_16_t      y_dst,
                     glitz_geometry_format_t *format,
-                    glitz_buffer_t *buffer);
+                    glitz_buffer_t          *buffer);
   
 
 /* glitz.c */
 
 void
 glitz_composite (glitz_operator_t op,
-                 glitz_surface_t *src,
-                 glitz_surface_t *mask,
-                 glitz_surface_t *dst,
-                 int x_src,
-                 int y_src,
-                 int x_mask,
-                 int y_mask,
-                 int x_dst,
-                 int y_dst,
-                 int width,
-                 int height);
+                 glitz_surface_t  *src,
+                 glitz_surface_t  *mask,
+                 glitz_surface_t  *dst,
+                 int              x_src,
+                 int              y_src,
+                 int              x_mask,
+                 int              y_mask,
+                 int              x_dst,
+                 int              y_dst,
+                 int              width,
+                 int              height);
 
 void
 glitz_copy_area (glitz_surface_t *src,
                  glitz_surface_t *dst,
-                 int x_src,
-                 int y_src,
-                 int width,
-                 int height,
-                 int x_dst,
-                 int y_dst);
+                 int             x_src,
+                 int             y_src,
+                 int             width,
+                 int             height,
+                 int             x_dst,
+                 int             y_dst);
   
 #if defined(__cplusplus) || defined(c_plusplus)
 }
diff --git a/glitz.pc.in b/src/glitz.pc.in
index fee3a7d..fee3a7d 100644
--- a/glitz.pc.in
+++ b/src/glitz.pc.in
diff --git a/src/glitz_agl_context.c b/src/glitz_agl_context.c
deleted file mode 100644
index 04c100c..0000000
--- a/src/glitz_agl_context.c
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_aglint.h"
-
-extern glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address;
-
-static void
-_glitz_agl_context_create (glitz_agl_thread_info_t *thread_info,
-                           AGLPixelFormat pixel_format,
-                           glitz_agl_context_t *context)
-{
-  context->context =
-    aglCreateContext (pixel_format, thread_info->root_context.context);
-  context->pixel_format = pixel_format;
-}
-
-glitz_agl_context_t *
-glitz_agl_context_get (glitz_agl_thread_info_t *thread_info,
-                       glitz_format_t *format,
-                       glitz_bool_t offscreen)
-{
-  glitz_agl_context_t *context;
-  glitz_agl_context_t **contexts = thread_info->contexts;
-  int index, n_contexts = thread_info->n_contexts;
-
-  if (thread_info->format_ids[format->id] == (AGLPixelFormat) 0)
-    return &thread_info->root_context;
-
-  for (; n_contexts; n_contexts--, contexts++)
-    if ((*contexts)->pixel_format == thread_info->format_ids[format->id] &&
-        (*contexts)->offscreen == offscreen)
-      return *contexts;
-  
-  index = thread_info->n_contexts++;
-
-  thread_info->contexts =
-    realloc (thread_info->contexts,
-             sizeof (glitz_agl_context_t *) * thread_info->n_contexts);
-
-  context = malloc (sizeof (glitz_agl_context_t));
-  thread_info->contexts[index] = context;
-
-  _glitz_agl_context_create (thread_info,
-                             thread_info->format_ids[format->id],
-                             context);
-  context->offscreen = offscreen;
-
-  glitz_agl_surface_backend_init (&context->backend);
-
-  memcpy (&context->backend.gl,
-          &_glitz_agl_gl_proc_address,
-          sizeof (glitz_gl_proc_address_list_t));
-  
-  context->backend.formats = thread_info->formats;
-  context->backend.n_formats = thread_info->n_formats;
-  context->backend.program_map = &thread_info->program_map;
-  context->backend.feature_mask = thread_info->feature_mask;
-
-  context->backend.gl.need_lookup = 1;
-  
-  return context;
-}
-
-void
-glitz_agl_context_destroy (glitz_agl_thread_info_t *thread_info,
-                           glitz_agl_context_t *context)
-{
-  aglDestroyContext (context->context);
-  free (context);
-}
-
-/* These function addresses are never context specific but we retrive them
-   for each context anyway. */
-void
-glitz_agl_context_proc_address_lookup (glitz_agl_thread_info_t *thread_info,
-                                       glitz_agl_context_t *context)
-{
-  CFBundleRef bundle;
-  
-  bundle = glitz_agl_get_bundle ("OpenGL.framework");
-
-  if (thread_info->feature_mask & GLITZ_FEATURE_BLEND_COLOR_MASK) {
-    if (thread_info->gl_version >= 1.4f) {
-      context->backend.gl.blend_color = (glitz_gl_blend_color_t)
-        glitz_agl_get_proc_address (bundle, "glBlendColor");
-    } else {
-      context->backend.gl.blend_color = (glitz_gl_blend_color_t)
-        glitz_agl_get_proc_address (bundle, "glBlendColorEXT");
-    }
-
-    if (!context->backend.gl.blend_color)
-      context->backend.feature_mask &= ~GLITZ_FEATURE_BLEND_COLOR_MASK;
-  }
-
-  if (thread_info->feature_mask & GLITZ_FEATURE_MULTITEXTURE_MASK) {
-    if (thread_info->gl_version >= 1.3f) {
-      context->backend.gl.active_texture = (glitz_gl_active_texture_t)
-        glitz_agl_get_proc_address (bundle, "glActiveTexture");
-    } else {
-      context->backend.gl.active_texture = (glitz_gl_active_texture_t)
-        glitz_agl_get_proc_address (bundle, "glActiveTextureARB");
-    }
-
-    if (!context->backend.gl.active_texture) {
-      context->backend.feature_mask &= ~GLITZ_FEATURE_MULTITEXTURE_MASK;
-      context->backend.feature_mask &=
-        ~GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK;
-    }
-  }
-
-  if (thread_info->feature_mask & GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK) {
-    context->backend.gl.gen_programs = (glitz_gl_gen_programs_t)
-      glitz_agl_get_proc_address (bundle, "glGenProgramsARB");
-    context->backend.gl.delete_programs = (glitz_gl_delete_programs_t)
-      glitz_agl_get_proc_address (bundle, "glDeleteProgramsARB");
-    context->backend.gl.program_string = (glitz_gl_program_string_t)
-      glitz_agl_get_proc_address (bundle, "glProgramStringARB");
-    context->backend.gl.bind_program = (glitz_gl_bind_program_t)
-      glitz_agl_get_proc_address (bundle, "glBindProgramARB");
-    context->backend.gl.program_local_param_4fv =
-      (glitz_gl_program_local_param_4fv_t)
-      glitz_agl_get_proc_address (bundle,
-                                  "glProgramLocalParameter4fvARB");
-    context->backend.gl.get_program_iv = (glitz_gl_get_program_iv_t)
-      glitz_agl_get_proc_address (bundle, "glGetProgramivARB");
-
-    if ((!context->backend.gl.gen_programs) ||
-        (!context->backend.gl.delete_programs) ||
-        (!context->backend.gl.program_string) ||
-        (!context->backend.gl.bind_program) ||
-        (!context->backend.gl.program_local_param_4fv))
-      context->backend.feature_mask &= ~GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK;
-  }
-
-  if ((thread_info->feature_mask & GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK) ||
-      (thread_info->feature_mask & GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK)) {
-    if (thread_info->gl_version >= 1.5f) {
-      context->backend.gl.gen_buffers = (glitz_gl_gen_buffers_t)
-        glitz_agl_get_proc_address (bundle, "glGenBuffers");
-      context->backend.gl.delete_buffers = (glitz_gl_delete_buffers_t)
-        glitz_agl_get_proc_address (bundle, "glDeleteBuffers");
-      context->backend.gl.bind_buffer = (glitz_gl_bind_buffer_t)
-        glitz_agl_get_proc_address (bundle, "glBindBuffer");
-      context->backend.gl.buffer_data = (glitz_gl_buffer_data_t)
-        glitz_agl_get_proc_address (bundle, "glBufferData");
-      context->backend.gl.buffer_sub_data = (glitz_gl_buffer_sub_data_t)
-        glitz_agl_get_proc_address (bundle, "glBufferSubData");
-      context->backend.gl.get_buffer_sub_data =
-        (glitz_gl_get_buffer_sub_data_t)
-        glitz_agl_get_proc_address (bundle, "glGetBufferSubData");
-      context->backend.gl.map_buffer = (glitz_gl_map_buffer_t)
-        glitz_agl_get_proc_address (bundle, "glMapBuffer");
-      context->backend.gl.unmap_buffer = (glitz_gl_unmap_buffer_t)
-        glitz_agl_get_proc_address (bundle, "glUnmapBuffer");
-    } else {
-      context->backend.gl.gen_buffers = (glitz_gl_gen_buffers_t)
-        glitz_agl_get_proc_address (bundle, "glGenBuffersARB");
-      context->backend.gl.delete_buffers = (glitz_gl_delete_buffers_t)
-        glitz_agl_get_proc_address (bundle, "glDeleteBuffersARB");
-      context->backend.gl.bind_buffer = (glitz_gl_bind_buffer_t)
-        glitz_agl_get_proc_address (bundle, "glBindBufferARB");
-      context->backend.gl.buffer_data = (glitz_gl_buffer_data_t)
-        glitz_agl_get_proc_address (bundle, "glBufferDataARB");
-      context->backend.gl.buffer_sub_data = (glitz_gl_buffer_sub_data_t)
-        glitz_agl_get_proc_address (bundle, "glBufferSubDataARB");
-      context->backend.gl.get_buffer_sub_data =
-        (glitz_gl_get_buffer_sub_data_t)
-        glitz_agl_get_proc_address (bundle, "glGetBufferSubDataARB");
-      context->backend.gl.map_buffer = (glitz_gl_map_buffer_t)
-        glitz_agl_get_proc_address (bundle, "glMapBufferARB");
-      context->backend.gl.unmap_buffer = (glitz_gl_unmap_buffer_t)
-        glitz_agl_get_proc_address (bundle, "glUnmapBufferARB");
-    }
-
-    if ((!context->backend.gl.gen_buffers) ||
-        (!context->backend.gl.delete_buffers) ||
-        (!context->backend.gl.bind_buffer) ||
-        (!context->backend.gl.buffer_data) ||
-        (!context->backend.gl.buffer_sub_data) ||
-        (!context->backend.gl.get_buffer_sub_data) ||
-        (!context->backend.gl.map_buffer) ||
-        (!context->backend.gl.unmap_buffer)) {
-      context->backend.feature_mask &=
-        ~GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK;
-      context->backend.feature_mask &= ~GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK;
-    }
-  }
-
-  glitz_agl_release_bundle (bundle);
-
-  context->backend.gl.get_integer_v (GLITZ_GL_MAX_VIEWPORT_DIMS,
-                                     context->max_viewport_dims);
-  context->backend.gl.get_integer_v (GLITZ_GL_MAX_TEXTURE_SIZE,
-                                     &context->max_texture_2d_size);
-  
-  if (thread_info->feature_mask & GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK)
-    context->backend.gl.get_integer_v (GLITZ_GL_MAX_RECTANGLE_TEXTURE_SIZE,
-                                       &context->max_texture_rect_size);
-  else
-    context->max_texture_rect_size = 0;
-  
-  context->backend.gl.need_lookup = 0;
-}
-
-void
-glitz_agl_context_make_current (glitz_agl_surface_t *surface,
-                                glitz_bool_t flush)
-{
-  AGLContext context;
-  AGLDrawable drawable = (AGLDrawable) 0;
-  AGLPbuffer pbuffer = (AGLPbuffer) 0;
-
-  if (flush)
-    glFlush ();
-  
-  if ((!surface->drawable) && (!surface->pbuffer)) {
-    context = surface->thread_info->root_context.context;
-  } else {
-    context = surface->context->context;
-    pbuffer = surface->pbuffer;
-    drawable = surface->drawable;
-    surface->base.update_mask |= GLITZ_UPDATE_ALL_MASK;
-  }
-
-  if (pbuffer)
-    aglSetPBuffer (context, pbuffer, 0, 0, aglGetVirtualScreen (context));
-  else
-    aglSetDrawable (context, drawable);
-
-  aglSetCurrentContext (context);
-
-  if (surface->context->backend.gl.need_lookup)
-    glitz_agl_context_proc_address_lookup (surface->thread_info,
-                                           surface->context);
-}
-
-static void
-glitz_agl_context_update (glitz_agl_surface_t *surface,
-                          glitz_constraint_t constraint)
-{
-  AGLContext context = aglGetCurrentContext ();
-
-  switch (constraint) {
-  case GLITZ_CN_NONE:
-    break;
-  case GLITZ_CN_ANY_CONTEXT_CURRENT:
-    if (context == NULL)
-      glitz_agl_context_make_current (surface, 0);
-    break;
-  case GLITZ_CN_SURFACE_CONTEXT_CURRENT:
-    if (context != surface->context->context)
-      glitz_agl_context_make_current (surface, (context)? 1: 0);
-    break;
-  case GLITZ_CN_SURFACE_DRAWABLE_CURRENT:
-    if (context != surface->context->context) {
-      glitz_agl_context_make_current (surface, (context)? 1: 0);
-    } else {
-      if (surface->pbuffer) {
-        AGLPbuffer pbuffer;
-        GLuint unused;
-
-        aglGetPBuffer (surface->context->context, &pbuffer,
-                       &unused, &unused, &unused);
-        
-        if (pbuffer != surface->pbuffer)
-          glitz_agl_context_make_current (surface, (context)? 1: 0);
-        
-      } else if (surface->drawable) {
-        if (aglGetDrawable (surface->context->context) != surface->drawable)
-          glitz_agl_context_make_current (surface, (context)? 1: 0);
-      }
-    }
-    break;
-  }
-}
-
-glitz_agl_surface_t *
-glitz_agl_context_push_current (glitz_agl_surface_t *surface,
-                                glitz_constraint_t constraint)
-{
-  glitz_agl_thread_info_t *thread_info;
-  glitz_agl_context_info_t *context_info;
-  int index;
-
-  thread_info = surface->thread_info;
-
-  index = thread_info->context_stack_size++;
-  
-  context_info = &thread_info->context_stack[index];
-  context_info->surface = surface;
-  context_info->constraint = constraint;
-  
-  glitz_agl_context_update (context_info->surface, constraint);
-
-  if (context_info->constraint == GLITZ_CN_SURFACE_DRAWABLE_CURRENT)
-    return context_info->surface;
-  
-  return NULL;
-}
-
-glitz_agl_surface_t *
-glitz_agl_context_pop_current (glitz_agl_surface_t *surface)
-{
-  glitz_agl_thread_info_t *thread_info;
-  glitz_agl_context_info_t *context_info = NULL;
-  int index;
-
-  thread_info = surface->thread_info;
-
-  thread_info->context_stack_size--;
-  index = thread_info->context_stack_size - 1;
-
-  context_info = &thread_info->context_stack[index];
-
-  if (context_info->surface)
-    glitz_agl_context_update (context_info->surface, context_info->constraint);
-  
-  if (context_info->constraint == GLITZ_CN_SURFACE_DRAWABLE_CURRENT)
-    return context_info->surface;
-  
-  return NULL;
-}
diff --git a/src/glitz_agl_extension.c b/src/glitz_agl_extension.c
deleted file mode 100644
index 99efa18..0000000
--- a/src/glitz_agl_extension.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_aglint.h"
-
-extern glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address;
-
-static glitz_extension_map gl_extensions[] = {
-  { 0.0, "GL_APPLE_pixel_buffer", GLITZ_AGL_FEATURE_PBUFFER_MASK },
-  { 0.0, "GL_ARB_texture_rectangle",
-    GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK },
-  { 0.0, "GL_EXT_texture_rectangle",
-    GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK },
-  { 0.0, "GL_NV_texture_rectangle", GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK },
-  { 0.0, "GL_ARB_texture_non_power_of_two",
-    GLITZ_AGL_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK },
-  { 0.0, "GL_ARB_texture_mirrored_repeat",
-    GLITZ_AGL_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK },
-  { 0.0, "GL_ARB_texture_border_clamp",
-    GLITZ_AGL_FEATURE_TEXTURE_BORDER_CLAMP_MASK },
-  { 0.0, "GL_ARB_texture_env_combine",
-    GLITZ_AGL_FEATURE_TEXTURE_ENV_COMBINE_MASK },
-  { 0.0, "GL_EXT_texture_env_combine",
-    GLITZ_AGL_FEATURE_TEXTURE_ENV_COMBINE_MASK },
-  { 0.0, "GL_ARB_texture_env_dot3", GLITZ_AGL_FEATURE_TEXTURE_ENV_DOT3_MASK },
-  { 0.0, "GL_ARB_multisample", GLITZ_AGL_FEATURE_MULTISAMPLE_MASK },
-  { 0.0, "GL_NV_multisample_filter_hint",
-    GLITZ_AGL_FEATURE_MULTISAMPLE_FILTER_HINT_MASK },
-  { 0.0, "GL_ARB_multitexture", GLITZ_AGL_FEATURE_MULTITEXTURE_MASK },
-  { 0.0, "GL_ARB_fragment_program", GLITZ_AGL_FEATURE_FRAGMENT_PROGRAM_MASK },
-  { 0.0, "GL_ARB_vertex_buffer_object",
-    GLITZ_AGL_FEATURE_VERTEX_BUFFER_OBJECT_MASK },
-  { 0.0, "GL_EXT_pixel_buffer_object",
-    GLITZ_AGL_FEATURE_PIXEL_BUFFER_OBJECT_MASK },
-  { 0.0, "GL_EXT_blend_color",
-    GLITZ_AGL_FEATURE_BLEND_COLOR_MASK },
-  { 0.0, "GL_ARB_imaging",
-    GLITZ_AGL_FEATURE_BLEND_COLOR_MASK },
-  { 0.0, NULL, 0 }
-};
-
-static unsigned long
-_glitz_agl_extension_query_gl (glitz_gl_float_t gl_version)
-{
-  const char *gl_extensions_string;
-  
-  gl_extensions_string = (const char *) glGetString (GL_EXTENSIONS);
-
-  return glitz_extensions_query (gl_version,
-                                 gl_extensions_string,
-                                 gl_extensions);
-}
-
-glitz_status_t
-glitz_agl_query_extensions (glitz_agl_thread_info_t *thread_info)
-{
-  thread_info->gl_version = atof ((const char *) glGetString (GL_VERSION));
-  if (thread_info->gl_version < 1.2)
-    return GLITZ_STATUS_NOT_SUPPORTED;
-  
-  thread_info->agl_feature_mask = 0;
-  
-  thread_info->agl_feature_mask |=
-    _glitz_agl_extension_query_gl (thread_info->gl_version);
-
-  thread_info->feature_mask = 0;
-
-  if (thread_info->agl_feature_mask & GLITZ_AGL_FEATURE_MULTISAMPLE_MASK) {
-    thread_info->feature_mask |= GLITZ_FEATURE_MULTISAMPLE_MASK;
-
-    if (thread_info->agl_feature_mask &
-        GLITZ_AGL_FEATURE_MULTISAMPLE_FILTER_HINT_MASK)
-      thread_info->feature_mask |= GLITZ_FEATURE_MULTISAMPLE_FILTER_HINT_MASK;
-    
-    /*
-      if (strcmp ("Card supporting pbuffer multisampling",
-      glGetString (GL_RENDERER)))
-      thread_info->feature_mask |= GLITZ_FEATURE_OFFSCREEN_MULTISAMPLE_MASK;
-    */
-  }
-
-  if (thread_info->agl_feature_mask &
-      GLITZ_AGL_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK)
-    thread_info->feature_mask |= GLITZ_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK;
-
-  if (thread_info->agl_feature_mask &
-      GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK)
-    thread_info->feature_mask |= GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK;
-
-  if (thread_info->agl_feature_mask &
-      GLITZ_AGL_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK)
-    thread_info->feature_mask |= GLITZ_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK;
-
-  if (thread_info->agl_feature_mask &
-      GLITZ_AGL_FEATURE_TEXTURE_BORDER_CLAMP_MASK)
-    thread_info->feature_mask |= GLITZ_FEATURE_TEXTURE_BORDER_CLAMP_MASK;
-
-  if (thread_info->agl_feature_mask & GLITZ_AGL_FEATURE_MULTITEXTURE_MASK) {
-    thread_info->feature_mask |= GLITZ_FEATURE_MULTITEXTURE_MASK;
-
-    if (thread_info->agl_feature_mask &
-        GLITZ_AGL_FEATURE_TEXTURE_ENV_COMBINE_MASK)
-      thread_info->feature_mask |= GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK;
-    
-    if (thread_info->agl_feature_mask &
-        GLITZ_AGL_FEATURE_TEXTURE_ENV_DOT3_MASK)
-      thread_info->feature_mask |= GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK;
-    
-    if ((thread_info->feature_mask & GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK) &&
-        (thread_info->feature_mask & GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK)) {
-      GLint max_texture_units;
-      
-      glGetIntegerv (GLITZ_GL_MAX_TEXTURE_UNITS, &max_texture_units);
-      if (max_texture_units >= 3)
-        thread_info->feature_mask |=
-          GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK;
-    }
-    
-    if (thread_info->agl_feature_mask &
-        GLITZ_AGL_FEATURE_FRAGMENT_PROGRAM_MASK)
-      thread_info->feature_mask |= GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK;
-  }
-
-  if (thread_info->agl_feature_mask &
-      GLITZ_AGL_FEATURE_VERTEX_BUFFER_OBJECT_MASK)
-    thread_info->feature_mask |= GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK;
-  
-  if (thread_info->agl_feature_mask &
-      GLITZ_AGL_FEATURE_PIXEL_BUFFER_OBJECT_MASK)
-    thread_info->feature_mask |= GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK;
-
-  if (thread_info->agl_feature_mask & GLITZ_AGL_FEATURE_BLEND_COLOR_MASK)
-    thread_info->feature_mask |= GLITZ_FEATURE_BLEND_COLOR_MASK;
-
-  return GLITZ_STATUS_SUCCESS;
-}
diff --git a/src/glitz_agl_format.c b/src/glitz_agl_format.c
deleted file mode 100644
index 1b945b9..0000000
--- a/src/glitz_agl_format.c
+++ /dev/null
@@ -1,368 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_aglint.h"
-
-#include <stdlib.h>
-
-extern glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address;
-
-static const struct _glx_pixel_format_attrib {
-  GLint attrib[20];
-} pixel_format_attrib_map[] = {
-  {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_ALPHA_SIZE, 0,
-      AGL_NO_RECOVERY,
-      AGL_NONE, 0, 0, 0, 0, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_ALPHA_SIZE, 8,
-      AGL_NO_RECOVERY,
-      AGL_NONE, 0, 0, 0, 0, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_NO_RECOVERY,
-      AGL_SAMPLE_BUFFERS_ARB, 1,
-      AGL_SAMPLES_ARB, 2,
-      AGL_NONE, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_NO_RECOVERY,
-      AGL_SAMPLE_BUFFERS_ARB, 1,
-      AGL_SAMPLES_ARB, 4,
-      AGL_NONE, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_ALPHA_SIZE, 0,
-      AGL_DEPTH_SIZE, 1,
-      AGL_NO_RECOVERY,
-      AGL_NONE, 0, 0, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_ALPHA_SIZE, 8,
-      AGL_DEPTH_SIZE, 1,
-      AGL_NO_RECOVERY,
-      AGL_NONE, 0, 0, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_DEPTH_SIZE, 1,
-      AGL_NO_RECOVERY,
-      AGL_SAMPLE_BUFFERS_ARB, 1,
-      AGL_SAMPLES_ARB, 2,
-      AGL_NONE, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_DEPTH_SIZE, 1,
-      AGL_NO_RECOVERY,
-      AGL_SAMPLE_BUFFERS_ARB, 1,
-      AGL_SAMPLES_ARB, 4,
-      AGL_NONE, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_ALPHA_SIZE, 0,
-      AGL_DEPTH_SIZE, 1,
-      AGL_STENCIL_SIZE, 2,
-      AGL_NO_RECOVERY,
-      AGL_NONE, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_ALPHA_SIZE, 8,
-      AGL_DEPTH_SIZE, 1,
-      AGL_STENCIL_SIZE, 2,
-      AGL_NO_RECOVERY,
-      AGL_NONE, 0, 0, 0, 0
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_DEPTH_SIZE, 1,
-      AGL_STENCIL_SIZE, 2,
-      AGL_NO_RECOVERY,
-      AGL_SAMPLE_BUFFERS_ARB, 1,
-      AGL_SAMPLES_ARB, 2,
-      AGL_NONE,
-    }
-  }, {
-    {
-      AGL_RGBA,
-      AGL_DOUBLEBUFFER,
-      AGL_RED_SIZE, 8,
-      AGL_GREEN_SIZE, 8,
-      AGL_BLUE_SIZE, 8,
-      AGL_DEPTH_SIZE, 1,
-      AGL_STENCIL_SIZE, 2,
-      AGL_NO_RECOVERY,
-      AGL_SAMPLE_BUFFERS_ARB, 1,
-      AGL_SAMPLES_ARB, 4,
-      AGL_NONE,
-    }
-  }, {
-    {
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    }
-  }
-};
-
-static int
-_glitz_agl_format_compare (const void *elem1,
-                           const void *elem2)
-{
-  int i, score[2];
-  glitz_format_t *format[2];
-  
-  format[0] = (glitz_format_t *) elem1;
-  format[1] = (glitz_format_t *) elem2;
-  i = score[0] = score[1] = 0;
-
-  for (; i < 2; i++) {
-    if (format[i]->red_size)
-      score[i] += 10;
-    if (format[i]->alpha_size)
-      score[i] += 10;
-    if (format[i]->stencil_size)
-      score[i] += (10 + format[i]->stencil_size);
-    if (format[i]->multisample.supported) 
-      score[i] -= (10 - format[i]->multisample.samples);
-  }
-  
-  return score[1] - score[0];
-}
-
-static void
-_glitz_add_format (glitz_agl_thread_info_t *thread_info,
-                   glitz_format_t *format)
-{
-  if (!glitz_format_find (thread_info->formats, thread_info->n_formats,
-                          GLITZ_FORMAT_ALL_EXCEPT_ID_MASK, format, 0)) {
-    int index = thread_info->n_formats++;
-    
-    thread_info->formats =
-      realloc (thread_info->formats,
-               sizeof (glitz_format_t) * thread_info->n_formats);
-  
-    thread_info->formats[index] = *format;
-  }
-}
-
-static void
-_glitz_move_out_ids (glitz_agl_thread_info_t *thread_info)
-{
-  int i;
-  glitz_format_t *formats = thread_info->formats;
-  int n_formats = thread_info->n_formats;
-
-  thread_info->format_ids = malloc (sizeof (AGLPixelFormat) * n_formats);
-  
-  for (i = 0; n_formats; n_formats--, formats++) {
-    thread_info->format_ids[i] = (AGLPixelFormat) formats->id;
-    formats->id = i++;
-  }
-}
-
-static void
-_glitz_agl_add_texture_format (glitz_format_t *texture_format, void *ptr)
-{
-  glitz_agl_thread_info_t *thread_info = (glitz_agl_thread_info_t *) ptr;
-  glitz_format_t format;
-
-  format = *texture_format;
-  format.id = 0;
-
-  _glitz_add_format (thread_info, &format);
-}
-
-void
-glitz_agl_query_formats (glitz_agl_thread_info_t *thread_info)
-{
-  glitz_format_t format;
-  AGLPixelFormat pixel_format;
-  int i = 0;
-
-  for (i = 0; *(pixel_format_attrib_map[i].attrib); i++) {
-    GLint value;
-
-    pixel_format = aglChoosePixelFormat (NULL, 0,
-                                         pixel_format_attrib_map[i].attrib);
-
-    /* Stereo is not supported yet */
-    if (!(aglDescribePixelFormat (pixel_format, AGL_STEREO, &value)) ||
-        value) {
-      aglDestroyPixelFormat (pixel_format);
-      continue;
-    }
-
-    aglDescribePixelFormat (pixel_format, AGL_DOUBLEBUFFER, &value);
-    format.doublebuffer = (value)? 1: 0;
-
-    /* We don't support single buffering in MacOS X */
-    if (!format.doublebuffer) {
-      aglDestroyPixelFormat (pixel_format);
-      continue;
-    }
-
-    format.id = (unsigned long int) pixel_format;
-
-    format.read.onscreen = format.draw.onscreen = 1;
-    if (thread_info->agl_feature_mask & GLITZ_AGL_FEATURE_PBUFFER_MASK)
-      format.read.offscreen = format.draw.offscreen = 1;
-    else
-      format.read.offscreen = format.draw.offscreen = 0;
-      
-    aglDescribePixelFormat (pixel_format, AGL_RED_SIZE, &value);
-    format.red_size = (unsigned short) value;
-    aglDescribePixelFormat (pixel_format, AGL_GREEN_SIZE, &value);
-    format.green_size = (unsigned short) value;
-    aglDescribePixelFormat (pixel_format, AGL_BLUE_SIZE, &value);
-    format.blue_size = (unsigned short) value;
-    aglDescribePixelFormat (pixel_format, AGL_ALPHA_SIZE, &value);
-    format.alpha_size = (unsigned short) value;
-    aglDescribePixelFormat (pixel_format, AGL_DEPTH_SIZE, &value);
-    format.depth_size = (unsigned short) value;
-    aglDescribePixelFormat (pixel_format, AGL_STENCIL_SIZE, &value);
-    format.stencil_size = (unsigned short) value;
-    
-    if (thread_info->feature_mask & GLITZ_FEATURE_MULTISAMPLE_MASK) {
-      aglDescribePixelFormat (pixel_format, AGL_SAMPLE_BUFFERS_ARB, &value);
-      format.multisample.supported = (value)? 1: 0;
-      aglDescribePixelFormat (pixel_format, AGL_SAMPLES_ARB, &value);
-      format.multisample.samples = (unsigned short) value;
-
-      if (format.multisample.supported) {
-        if (!(thread_info->feature_mask &
-              GLITZ_FEATURE_OFFSCREEN_MULTISAMPLE_MASK))
-          format.read.offscreen = format.draw.offscreen = 0;
-      }
-    } else {
-      format.multisample.supported = 0;
-      format.multisample.samples = 0;
-    }
-
-    if (format.red_size || format.green_size || format.blue_size ||
-        format.alpha_size)
-      _glitz_add_format (thread_info, &format);
-  }
-
-  qsort (thread_info->formats, thread_info->n_formats,
-         sizeof (glitz_format_t), _glitz_agl_format_compare);
-
-  glitz_format_for_each_texture_format (&_glitz_agl_add_texture_format,
-                                        &_glitz_agl_gl_proc_address,
-                                        (void *) thread_info);
-  
-  _glitz_move_out_ids (thread_info);
-}
-
-glitz_format_t *
-glitz_agl_find_format (unsigned long mask,
-                       const glitz_format_t *templ,
-                       int count)
-{
-  glitz_agl_thread_info_t *thread_info = glitz_agl_thread_info_get ();
-
-  return glitz_format_find (thread_info->formats, thread_info->n_formats,
-                            mask, templ, count);
-}
-slim_hidden_def(glitz_agl_find_format);
-
-glitz_format_t *
-glitz_agl_find_standard_format (glitz_format_name_t format_name)
-{
-  glitz_agl_thread_info_t *thread_info = glitz_agl_thread_info_get ();
-  
-  return
-    glitz_format_find_standard (thread_info->formats, thread_info->n_formats,
-                                format_name);
-}
-slim_hidden_def(glitz_agl_find_standard_format);
diff --git a/src/glitz_agl_pbuffer.c b/src/glitz_agl_pbuffer.c
deleted file mode 100644
index 0e8f3af..0000000
--- a/src/glitz_agl_pbuffer.c
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_aglint.h"
-
-extern glitz_gl_proc_address_list_t _glitz_agl_gl_proc_address;
-
-AGLPbuffer
-glitz_agl_pbuffer_create (glitz_texture_t *texture)
-{
-  AGLPbuffer pbuffer;
-
-  aglCreatePBuffer (texture->width, texture->height,
-                    texture->target, texture->format, 0, &pbuffer);
-
-  return pbuffer;
-}
-
-void 
-glitz_agl_pbuffer_destroy (AGLPbuffer pbuffer)
-{
-  aglDestroyPBuffer (pbuffer);
-}
diff --git a/src/glitz_agl_surface.c b/src/glitz_agl_surface.c
deleted file mode 100644
index 47da21a..0000000
--- a/src/glitz_agl_surface.c
+++ /dev/null
@@ -1,327 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_aglint.h"
-
-static glitz_bool_t
-_glitz_agl_surface_push_current (void *abstract_surface,
-                                 glitz_constraint_t constraint)
-{
-  glitz_agl_surface_t *surface = (glitz_agl_surface_t *) abstract_surface;
-  glitz_bool_t success = 1;
-  
-  if (constraint == GLITZ_CN_SURFACE_DRAWABLE_CURRENT &&
-      (!surface->pbuffer) && (!surface->drawable)) {
-    if (surface->base.format->draw.offscreen) {
-      surface->pbuffer = glitz_agl_pbuffer_create (&surface->base.texture);
-    } else {
-      constraint = GLITZ_CN_ANY_CONTEXT_CURRENT;
-      success = 0;
-    }
-  }
-  
-  surface = glitz_agl_context_push_current (surface, constraint);
-
-  if (surface) {
-    glitz_surface_update_state (&surface->base);
-    return 1;
-  }
-
-  return success;
-}
-
-static void
-_glitz_agl_surface_pop_current (void *abstract_surface)
-{
-  glitz_agl_surface_t *surface = (glitz_agl_surface_t *) abstract_surface;
-
-  surface = glitz_agl_context_pop_current (surface);
-  
-  if (surface)
-    glitz_surface_update_state (&surface->base);
-}
-
-static glitz_bool_t
-_glitz_agl_surface_make_current_read (void *abstract_surface)
-{
-  return 0;
-}
-
-static glitz_texture_t *
-_glitz_agl_surface_get_texture (void *abstract_surface,
-                                glitz_bool_t allocate) {
-  glitz_agl_surface_t *surface = (glitz_agl_surface_t *) abstract_surface;
-
-  if (surface->base.flags & GLITZ_SURFACE_FLAG_DIRTY_MASK) {
-    glitz_bounding_box_t copy_box;
-
-    copy_box.x1 = copy_box.y1 = 0;
-    copy_box.x2 = surface->base.width;
-    copy_box.y2 = surface->base.height;
-    glitz_intersect_bounding_box (&surface->base.dirty_box,
-                                  &copy_box, &copy_box);
-
-    if (!(TEXTURE_ALLOCATED (&surface->base.texture)))
-      glitz_texture_allocate (&surface->base.backend->gl,
-                              &surface->base.texture);  
-      
-    glitz_texture_copy_surface (&surface->base.texture, &surface->base,
-                                copy_box.x1,
-                                copy_box.y1,
-                                copy_box.x2 - copy_box.x1,
-                                copy_box.y2 - copy_box.y1,
-                                copy_box.x1,
-                                copy_box.y1);
-    
-    surface->base.flags &= ~GLITZ_SURFACE_FLAG_DIRTY_MASK;
-  }
-
-  if (allocate) {
-    if (!(TEXTURE_ALLOCATED (&surface->base.texture)))
-      glitz_texture_allocate (&surface->base.backend->gl,
-                              &surface->base.texture);
-  }
-  
-  if (TEXTURE_ALLOCATED (&surface->base.texture))
-    return &surface->base.texture;
-  else
-    return NULL;
-}
-
-static glitz_surface_t *
-_glitz_agl_surface_create (glitz_agl_thread_info_t *thread_info,
-                           glitz_format_t *format,
-                           int width,
-                           int height)
-{
-  glitz_agl_surface_t *surface;
-  glitz_agl_context_t *context;
-
-  if (width <= 0 || height <= 0)
-    return NULL;
-
-  context = glitz_agl_context_get (thread_info, format, 1);
-  if (!context)
-    return NULL;
-
-  surface = (glitz_agl_surface_t *) calloc (1, sizeof (glitz_agl_surface_t));
-  if (surface == NULL)
-    return NULL;
-  
-  glitz_surface_init (&surface->base,
-                      &context->backend,
-                      format,
-                      width,
-                      height);
-  
-  surface->thread_info = thread_info;
-  surface->context = context;
-
-  surface->base.flags |= GLITZ_SURFACE_FLAG_OFFSCREEN_MASK;
-
-  if (format->draw.offscreen)
-    surface->base.flags |= GLITZ_SURFACE_FLAG_DRAWABLE_MASK;
-
-  if (surface->context->backend.gl.need_lookup) {
-    glitz_agl_context_push_current (surface, GLITZ_CN_SURFACE_CONTEXT_CURRENT);
-    glitz_agl_context_pop_current (surface);
-  }
-
-  if (width > 64 || height > 64) {
-    glitz_agl_context_push_current (surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
-    glitz_texture_size_check (&surface->base.backend->gl,
-                              &surface->base.texture,
-                              context->max_texture_2d_size,
-                              context->max_texture_rect_size);
-    glitz_agl_context_pop_current (surface);
-    if (TEXTURE_INVALID_SIZE (&surface->base.texture) ||
-        (format->draw.offscreen &&
-         ((width > context->max_viewport_dims[0]) ||
-          (height > context->max_viewport_dims[1])))) {
-      glitz_surface_destroy (&surface->base);
-      return NULL;
-    }
-  }
-
-  return &surface->base;
-}
-
-glitz_surface_t *
-glitz_agl_surface_create (glitz_format_t *format,
-                          int width,
-                          int height)
-{
-  glitz_agl_thread_info_t *thread_info;
-
-  thread_info = glitz_agl_thread_info_get ();
-  if (!thread_info)
-    return NULL;
-  
-  return _glitz_agl_surface_create (thread_info, format, width, height);
-}
-slim_hidden_def(glitz_agl_surface_create_offscreen);
-
-glitz_surface_t *
-glitz_agl_surface_create_for_window (glitz_format_t *format,
-                                     WindowRef window,
-                                     int width,
-                                     int height)
-{
-  glitz_agl_surface_t *surface;
-  glitz_agl_context_t *context;
-  glitz_agl_thread_info_t *thread_info;
-  AGLDrawable drawable;
-
-  if (width <= 0 || height <= 0)
-    return NULL;
-
-  drawable = GetWindowPort (window);
-  if (!drawable)
-    return NULL;
-
-  thread_info = glitz_agl_thread_info_get ();
-  if (!thread_info)
-    return NULL;
-
-  context = glitz_agl_context_get (thread_info, format, 0);
-  if (!context)
-    return NULL;
-
-  surface = (glitz_agl_surface_t *) calloc (1, sizeof (glitz_agl_surface_t));
-  if (surface == NULL)
-    return NULL;
-
-  glitz_surface_init (&surface->base,
-                      &context->backend,
-                      format,
-                      width,
-                      height);
-  
-  surface->thread_info = thread_info;
-  surface->context = context;
-  surface->window = window;
-  surface->drawable = drawable;
-
-  surface->base.flags |= GLITZ_SURFACE_FLAG_DRAWABLE_MASK;
-
-  if (surface->context->backend.gl.need_lookup) {
-    glitz_agl_context_push_current (surface, GLITZ_CN_SURFACE_CONTEXT_CURRENT);
-    glitz_agl_context_pop_current (surface);
-  }
-
-  if (width > 64 || height > 64) {
-    glitz_agl_context_push_current (surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
-    glitz_texture_size_check (&surface->base.backend->gl,
-                              &surface->base.texture,
-                              context->max_texture_2d_size,
-                              context->max_texture_rect_size);
-    glitz_agl_context_pop_current (surface);
-    if (TEXTURE_INVALID_SIZE (&surface->base.texture) ||
-        (width > context->max_viewport_dims[0]) ||
-        (height > context->max_viewport_dims[1])) {
-      glitz_surface_destroy (&surface->base);
-      return NULL;
-    }
-  }
-  
-  return &surface->base;
-}
-slim_hidden_def(glitz_agl_surface_create_for_window);
-
-static glitz_surface_t *
-_glitz_agl_surface_create_similar (void *abstract_templ,
-                                   glitz_format_t *format,
-                                   int width,
-                                   int height)
-{
-  glitz_agl_surface_t *templ = (glitz_agl_surface_t *) abstract_templ;
-
-  if (!format->read.offscreen)
-    return NULL;
-  
-  return _glitz_agl_surface_create (templ->thread_info, format, width, height);
-}
-
-static void
-_glitz_agl_surface_destroy (void *abstract_surface)
-{
-  glitz_agl_surface_t *surface = (glitz_agl_surface_t *) abstract_surface;
-
-  glitz_surface_fini (&surface->base);
-  
-  if (surface->drawable || surface->pbuffer) {
-    AGLContext context = aglGetCurrentContext ();
-    
-    if (context == surface->context->context) { 
-      if (surface->pbuffer) {
-        AGLPbuffer pbuffer;
-        GLuint unused;
-        
-        aglGetPBuffer (context, &pbuffer, &unused, &unused, &unused);
-        
-        if (pbuffer == surface->pbuffer)
-          glitz_agl_context_make_current (surface, 0);
-      } else {
-        if (aglGetDrawable (context) == surface->drawable)
-          glitz_agl_context_make_current (surface, 0);
-      }
-    }
-    
-    if (surface->pbuffer)
-      glitz_agl_pbuffer_destroy (surface->pbuffer);
-  }
-  
-  free (surface);
-}
-
-static void
-_glitz_agl_surface_swap_buffers (void *abstract_surface)
-{
-  glitz_agl_surface_t *surface = (glitz_agl_surface_t *) abstract_surface;
-  
-  glitz_agl_context_push_current (surface, GLITZ_CN_SURFACE_DRAWABLE_CURRENT);
-
-  aglSwapBuffers (surface->context->context);
-  
-  glitz_agl_context_pop_current (surface);
-}
-
-void
-glitz_agl_surface_backend_init (glitz_surface_backend_t *backend)
-{
-  backend->create_similar = _glitz_agl_surface_create_similar;
-  backend->destroy = _glitz_agl_surface_destroy;
-  backend->push_current = _glitz_agl_surface_push_current;
-  backend->pop_current = _glitz_agl_surface_pop_current;
-  backend->get_texture = _glitz_agl_surface_get_texture;
-  backend->swap_buffers = _glitz_agl_surface_swap_buffers;
-  backend->make_current_read = _glitz_agl_surface_make_current_read;
-}
diff --git a/src/glitz_aglint.h b/src/glitz_aglint.h
deleted file mode 100644
index 5f5ff77..0000000
--- a/src/glitz_aglint.h
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifndef GLITZ_AGLINT_H_INCLUDED
-#define GLITZ_AGLINT_H_INCLUDED
-
-#include "glitzint.h"
-
-#include "glitz-agl.h"
-
-#include <OpenGL/gl.h>
-#include <Carbon/Carbon.h>
-#include <AGL/agl.h>
-
-#define GLITZ_AGL_FEATURE_PBUFFER_MASK                  (1L <<  0)
-#define GLITZ_AGL_FEATURE_TEXTURE_RECTANGLE_MASK        (1L <<  1)
-#define GLITZ_AGL_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK (1L <<  2)
-#define GLITZ_AGL_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK  (1L <<  3)
-#define GLITZ_AGL_FEATURE_TEXTURE_BORDER_CLAMP_MASK     (1L <<  4)
-#define GLITZ_AGL_FEATURE_MULTISAMPLE_MASK              (1L <<  5)
-#define GLITZ_AGL_FEATURE_MULTISAMPLE_FILTER_HINT_MASK  (1L <<  6)
-#define GLITZ_AGL_FEATURE_MULTITEXTURE_MASK             (1L <<  7)
-#define GLITZ_AGL_FEATURE_TEXTURE_ENV_COMBINE_MASK      (1L <<  8)
-#define GLITZ_AGL_FEATURE_TEXTURE_ENV_DOT3_MASK         (1L <<  9)
-#define GLITZ_AGL_FEATURE_FRAGMENT_PROGRAM_MASK         (1L << 10)
-#define GLITZ_AGL_FEATURE_VERTEX_BUFFER_OBJECT_MASK     (1L << 11)
-#define GLITZ_AGL_FEATURE_PIXEL_BUFFER_OBJECT_MASK      (1L << 12)
-#define GLITZ_AGL_FEATURE_BLEND_COLOR_MASK              (1L << 13)
-
-typedef struct _glitz_agl_surface_t glitz_agl_surface_t;
-
-typedef struct _glitz_agl_context_info_t {
-  glitz_agl_surface_t *surface;
-  glitz_constraint_t constraint;
-} glitz_agl_context_info_t;
-
-typedef struct _glitz_agl_context_t {
-  AGLContext context;
-  AGLPixelFormat pixel_format;
-  glitz_bool_t offscreen;
-  glitz_surface_backend_t backend;
-  glitz_gl_int_t max_viewport_dims[2];
-  glitz_gl_int_t max_texture_2d_size;
-  glitz_gl_int_t max_texture_rect_size;
-} glitz_agl_context_t;
-
-typedef struct _glitz_agl_thread_info_t {
-  glitz_format_t *formats;
-  AGLPixelFormat *format_ids;
-  int n_formats;
-  
-  glitz_agl_context_t **contexts;
-  int n_contexts;
-  
-  glitz_agl_context_info_t context_stack[GLITZ_CONTEXT_STACK_SIZE];
-  int context_stack_size;
-  
-  glitz_agl_context_t root_context;
-
-  unsigned long feature_mask;
-  unsigned long agl_feature_mask;
-  glitz_gl_float_t gl_version;
-
-  glitz_program_map_t program_map;
-} glitz_agl_thread_info_t;
-
-struct _glitz_agl_surface_t {
-  glitz_surface_t base;
-  
-  glitz_agl_thread_info_t *thread_info;
-  glitz_agl_context_t *context;
-  AGLDrawable drawable;
-  AGLPbuffer pbuffer;
-  WindowRef window;
-  glitz_gl_enum_t bound_buffer;
-};
-
-extern glitz_status_t __internal_linkage
-glitz_agl_query_extensions (glitz_agl_thread_info_t *thread_info);
-
-extern glitz_agl_thread_info_t *__internal_linkage
-glitz_agl_thread_info_get (void);
-
-extern CFBundleRef __internal_linkage
-glitz_agl_get_bundle (const char *name);
-
-extern void __internal_linkage
-glitz_agl_release_bundle (CFBundleRef bundle);
-
-extern glitz_function_pointer_t __internal_linkage
-glitz_agl_get_proc_address (CFBundleRef bundle, const char *name);
-
-extern glitz_agl_context_t *__internal_linkage
-glitz_agl_context_get (glitz_agl_thread_info_t *thread_info,
-                       glitz_format_t *format,
-                       glitz_bool_t offscreen);
-
-extern void __internal_linkage
-glitz_agl_context_destroy (glitz_agl_thread_info_t *thread_info,
-                           glitz_agl_context_t *context);
-
-extern void __internal_linkage
-glitz_agl_context_make_current (glitz_agl_surface_t *surface,
-                                glitz_bool_t flush);
-
-extern glitz_agl_surface_t *__internal_linkage
-glitz_agl_context_push_current (glitz_agl_surface_t *surface,
-                                glitz_constraint_t constraint);
-
-extern glitz_agl_surface_t *__internal_linkage
-glitz_agl_context_pop_current (glitz_agl_surface_t *surface);
-
-extern void __internal_linkage
-glitz_agl_context_proc_address_lookup (glitz_agl_thread_info_t *thread_info,
-                                       glitz_agl_context_t *context);
-
-extern void __internal_linkage
-glitz_agl_query_formats (glitz_agl_thread_info_t *thread_info);
-
-extern AGLPbuffer __internal_linkage
-glitz_agl_pbuffer_create (glitz_texture_t *texture);
-
-extern void __internal_linkage
-glitz_agl_pbuffer_destroy (AGLPbuffer pbuffer);
-
-extern void __internal_linkage
-glitz_agl_surface_backend_init (glitz_surface_backend_t *backend);
-
-
-/* Avoid unnecessary PLT entries.  */
-
-slim_hidden_proto(glitz_agl_init)
-slim_hidden_proto(glitz_agl_fini)
-slim_hidden_proto(glitz_agl_find_format)
-slim_hidden_proto(glitz_agl_find_standard_format)
-slim_hidden_proto(glitz_agl_surface_create)
-slim_hidden_proto(glitz_agl_surface_create_for_window)
-
-#endif /* GLITZ_AGLINT_H_INCLUDED */
diff --git a/src/glitz_buffer.c b/src/glitz_buffer.c
index f27ee61..32abc2d 100644
--- a/src/glitz_buffer.c
+++ b/src/glitz_buffer.c
@@ -30,17 +30,17 @@
 #include "glitzint.h"
 
 static glitz_status_t
-_glitz_buffer_init (glitz_buffer_t *buffer,
-                    glitz_surface_t *surface,
-                    void *data,
-                    unsigned int size,
+_glitz_buffer_init (glitz_buffer_t      *buffer,
+                    glitz_drawable_t    *drawable,
+                    void                *data,
+                    unsigned int        size,
                     glitz_buffer_hint_t hint)
 {
   glitz_gl_enum_t usage;
 
   buffer->ref_count = 1;
   buffer->name = 0;
-  
+
   switch (hint) {
   case GLITZ_BUFFER_HINT_STREAM_DRAW:
     usage = GLITZ_GL_STREAM_DRAW;
@@ -71,21 +71,26 @@ _glitz_buffer_init (glitz_buffer_t *buffer,
     break;
   }
   
-  if (surface) {
-    buffer->surface = surface;
-    glitz_surface_reference (surface);
+  if (drawable) {
+
+    GLITZ_GL_DRAWABLE (drawable);
+    
+    buffer->drawable = drawable;
+    glitz_drawable_reference (drawable);
 
-    glitz_surface_push_current (buffer->surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
+    drawable->backend->push_current (drawable, NULL,
+                                     GLITZ_ANY_CONTEXT_CURRENT);
 
-    surface->backend->gl.gen_buffers (1, &buffer->name);
+    gl->gen_buffers (1, &buffer->name);
     if (buffer->name) {
-      surface->backend->gl.bind_buffer (buffer->target, buffer->name);
-      surface->backend->gl.buffer_data (buffer->target, size, data, usage);
-      surface->backend->gl.bind_buffer (buffer->target, 0);
+      gl->bind_buffer (buffer->target, buffer->name);
+      gl->buffer_data (buffer->target, size, data, usage);
+      gl->bind_buffer (buffer->target, 0);
     }
-    glitz_surface_pop_current (buffer->surface);
+    
+    drawable->backend->pop_current (drawable);
   } else
-    buffer->surface = NULL;
+    buffer->drawable = NULL;
   
   if (size > 0 && buffer->name == 0) {
     buffer->data = malloc (size);
@@ -105,9 +110,9 @@ _glitz_buffer_init (glitz_buffer_t *buffer,
 }
 
 glitz_buffer_t *
-glitz_geometry_buffer_create (glitz_surface_t *surface,
-                              void *data,
-                              unsigned int size,
+glitz_geometry_buffer_create (glitz_drawable_t    *drawable,
+                              void                *data,
+                              unsigned int        size,
                               glitz_buffer_hint_t hint)
 {
   glitz_buffer_t *buffer;
@@ -116,14 +121,15 @@ glitz_geometry_buffer_create (glitz_surface_t *surface,
   if (size == 0)
     return NULL;
 
-  buffer = malloc (sizeof (glitz_buffer_t));
+  buffer = (glitz_buffer_t *) malloc (sizeof (glitz_buffer_t));
   if (buffer == NULL)
     return NULL;
   
   buffer->target = GLITZ_GL_ARRAY_BUFFER;
-
-  if (surface->backend->feature_mask & GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK)
-    status = _glitz_buffer_init (buffer, surface, data, size, hint);
+  
+  if (drawable->backend->feature_mask &
+      GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK)
+    status = _glitz_buffer_init (buffer, drawable, data, size, hint);
   else
     status = _glitz_buffer_init (buffer, NULL, data, size, hint);
   
@@ -136,9 +142,9 @@ glitz_geometry_buffer_create (glitz_surface_t *surface,
 }
 
 glitz_buffer_t *
-glitz_pixel_buffer_create (glitz_surface_t *surface,
-                           void *data,
-                           unsigned int size,
+glitz_pixel_buffer_create (glitz_drawable_t    *drawable,
+                           void                *data,
+                           unsigned int        size,
                            glitz_buffer_hint_t hint)
 {
   glitz_buffer_t *buffer;
@@ -147,7 +153,7 @@ glitz_pixel_buffer_create (glitz_surface_t *surface,
   if (size == 0)
     return NULL;
   
-  buffer = malloc (sizeof (glitz_buffer_t));
+  buffer = (glitz_buffer_t *) malloc (sizeof (glitz_buffer_t));
   if (buffer == NULL)
     return NULL;
   
@@ -162,8 +168,8 @@ glitz_pixel_buffer_create (glitz_surface_t *surface,
     break;
   }
 
-  if (surface->backend->feature_mask & GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK)
-    status = _glitz_buffer_init (buffer, surface, data, size, hint);
+  if (drawable->backend->feature_mask & GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK)
+    status = _glitz_buffer_init (buffer, drawable, data, size, hint);
   else
     status = _glitz_buffer_init (buffer, NULL, data, size, hint);
 
@@ -183,7 +189,7 @@ glitz_buffer_create_for_data (void *data)
   if (data == NULL)
     return NULL;
   
-  buffer = malloc (sizeof (glitz_buffer_t));
+  buffer = (glitz_buffer_t *) malloc (sizeof (glitz_buffer_t));
   if (buffer == NULL)
     return NULL;
 
@@ -205,11 +211,12 @@ glitz_buffer_destroy (glitz_buffer_t *buffer)
   if (buffer->ref_count)
     return;
   
-  if (buffer->surface) {
-    glitz_surface_push_current (buffer->surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
-    buffer->surface->backend->gl.delete_buffers (1, &buffer->name);
-    glitz_surface_pop_current (buffer->surface);
-    glitz_surface_destroy (buffer->surface);
+  if (buffer->drawable) {
+    buffer->drawable->backend->push_current (buffer->drawable, NULL,
+                                             GLITZ_ANY_CONTEXT_CURRENT);
+    buffer->drawable->backend->gl.delete_buffers (1, &buffer->name);
+    buffer->drawable->backend->pop_current (buffer->drawable);
+    glitz_drawable_destroy (buffer->drawable);
   } else if (buffer->owns_data)
     free (buffer->data);
   
@@ -227,19 +234,19 @@ glitz_buffer_reference (glitz_buffer_t *buffer)
 
 void
 glitz_buffer_set_data (glitz_buffer_t *buffer,
-                       int offset,
-                       unsigned int size,
-                       const void *data)
+                       int            offset,
+                       unsigned int   size,
+                       const void     *data)
 {
-  if (buffer->surface) {
-    glitz_surface_push_current (buffer->surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
-    
-    buffer->surface->backend->gl.bind_buffer (buffer->target, buffer->name);
-    buffer->surface->backend->gl.buffer_sub_data (buffer->target,
-                                                  offset, size, data);
-    buffer->surface->backend->gl.bind_buffer (buffer->target, 0);
+  if (buffer->drawable) {
+    GLITZ_GL_DRAWABLE (buffer->drawable);
     
-    glitz_surface_pop_current (buffer->surface);
+    buffer->drawable->backend->push_current (buffer->drawable, NULL,
+                                             GLITZ_ANY_CONTEXT_CURRENT);
+    gl->bind_buffer (buffer->target, buffer->name);
+    gl->buffer_sub_data (buffer->target, offset, size, data);
+    gl->bind_buffer (buffer->target, 0);
+    buffer->drawable->backend->pop_current (buffer->drawable);
   } else if (buffer->data)
     memcpy ((char *) buffer->data + offset, data, size);
 }
@@ -247,34 +254,39 @@ slim_hidden_def(glitz_buffer_set_data);
 
 void
 glitz_buffer_get_data (glitz_buffer_t *buffer,
-                       int offset,
-                       unsigned int size,
-                       void *data)
+                       int            offset,
+                       unsigned int   size,
+                       void           *data)
 {
-  if (buffer->surface) {
-    glitz_surface_push_current (buffer->surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
+  if (buffer->drawable) {
+    GLITZ_GL_DRAWABLE (buffer->drawable);
     
-    buffer->surface->backend->gl.bind_buffer (buffer->target, buffer->name);
-    buffer->surface->backend->gl.get_buffer_sub_data (buffer->target,
-                                                      offset, size, data);
-    buffer->surface->backend->gl.bind_buffer (buffer->target, 0);
+    buffer->drawable->backend->push_current (buffer->drawable, NULL,
+                                             GLITZ_ANY_CONTEXT_CURRENT);
     
-    glitz_surface_pop_current (buffer->surface);
+    gl->bind_buffer (buffer->target, buffer->name);
+    gl->get_buffer_sub_data (buffer->target, offset, size, data);
+    gl->bind_buffer (buffer->target, 0);
+
+    buffer->drawable->backend->pop_current (buffer->drawable);
   } else if (buffer->data)
     memcpy (data, (char *) buffer->data + offset, size);
 }
 slim_hidden_def(glitz_buffer_get_data);
 
 void *
-glitz_buffer_map (glitz_buffer_t *buffer,
+glitz_buffer_map (glitz_buffer_t        *buffer,
                   glitz_buffer_access_t access)
 {
   void *pointer = NULL;
   
-  if (buffer->surface) {
+  if (buffer->drawable) {
     glitz_gl_enum_t buffer_access;
-    
-    glitz_surface_push_current (buffer->surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
+
+    GLITZ_GL_DRAWABLE (buffer->drawable);
+
+    buffer->drawable->backend->push_current (buffer->drawable, NULL,
+                                             GLITZ_ANY_CONTEXT_CURRENT);
     
     switch (access) {
     case GLITZ_BUFFER_ACCESS_READ_ONLY:
@@ -288,11 +300,10 @@ glitz_buffer_map (glitz_buffer_t *buffer,
       break;
     }
 
-    buffer->surface->backend->gl.bind_buffer (buffer->target, buffer->name);
-    pointer = buffer->surface->backend->gl.map_buffer (buffer->target,
-                                                       buffer_access);
+    gl->bind_buffer (buffer->target, buffer->name);
+    pointer = gl->map_buffer (buffer->target, buffer_access);
     
-    glitz_surface_pop_current (buffer->surface);
+    buffer->drawable->backend->pop_current (buffer->drawable);
   }
   
   if (pointer == NULL)
@@ -306,16 +317,18 @@ glitz_buffer_unmap (glitz_buffer_t *buffer)
 {
   glitz_status_t status = GLITZ_STATUS_SUCCESS;
   
-  if (buffer->surface) {
-    glitz_surface_push_current (buffer->surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
+  if (buffer->drawable) {
+    GLITZ_GL_DRAWABLE (buffer->drawable);
     
-    if (buffer->surface->backend->gl.unmap_buffer (buffer->target) ==
-        GLITZ_GL_FALSE)
+    buffer->drawable->backend->push_current (buffer->drawable, NULL,
+                                             GLITZ_ANY_CONTEXT_CURRENT);
+    
+    if (gl->unmap_buffer (buffer->target) == GLITZ_GL_FALSE)
       status = GLITZ_STATUS_CONTENT_DESTROYED;
       
-    buffer->surface->backend->gl.bind_buffer (buffer->target, 0);
-    
-    glitz_surface_pop_current (buffer->surface);
+    gl->bind_buffer (buffer->target, 0);
+
+    buffer->drawable->backend->pop_current (buffer->drawable);
   }
 
   return status;
@@ -325,8 +338,8 @@ void *
 glitz_buffer_bind (glitz_buffer_t *buffer,
                    glitz_gl_enum_t target)
 {
-  if (buffer->surface) {
-    buffer->surface->backend->gl.bind_buffer (target, buffer->name);
+  if (buffer->drawable) {
+    buffer->drawable->backend->gl.bind_buffer (target, buffer->name);
     buffer->target = target;
     
     return NULL;
@@ -338,6 +351,6 @@ glitz_buffer_bind (glitz_buffer_t *buffer,
 void
 glitz_buffer_unbind (glitz_buffer_t *buffer)
 {
-  if (buffer->surface)
-    buffer->surface->backend->gl.bind_buffer (buffer->target, 0);
+  if (buffer->drawable)
+    buffer->drawable->backend->gl.bind_buffer (buffer->target, 0);
 }
diff --git a/src/glitz_compose.c b/src/glitz_compose.c
index afac19c..1f7ff83 100644
--- a/src/glitz_compose.c
+++ b/src/glitz_compose.c
@@ -449,12 +449,13 @@ glitz_composite_op_init (glitz_composite_op_t *op,
   glitz_surface_type_t src_type;
   glitz_surface_type_t mask_type;
   glitz_combine_t *combine;
+  unsigned long feature_mask;
 
   op->render_op = render_op;
   op->type = GLITZ_COMBINE_TYPE_NA;
   op->combine = NULL;
   op->alpha_mask = _default_alpha_mask;
-  op->gl = &dst->backend->gl;
+  op->gl = &dst->drawable->backend->gl;
   op->src = src;
   op->mask = mask;
   op->dst = dst;
@@ -463,14 +464,16 @@ glitz_composite_op_init (glitz_composite_op_t *op,
   op->per_component = 0;
   op->fp = 0;
 
-  if (dst->indirect && (dst->format->stencil_size < 1))
+  feature_mask = dst->attached->backend->feature_mask;
+
+  if (dst->indirect && (dst->attached->format->stencil_size < 1))
     return;
   
-  src_type = _glitz_get_surface_type (src, dst->backend->feature_mask);
+  src_type = _glitz_get_surface_type (src, feature_mask);
   if (src_type < 1)
     return;
 
-  mask_type = _glitz_get_surface_type (mask, dst->backend->feature_mask);
+  mask_type = _glitz_get_surface_type (mask, feature_mask);
   if (mask_type < 0)
     return;
 
@@ -488,62 +491,51 @@ glitz_composite_op_init (glitz_composite_op_t *op,
     src_type = GLITZ_SURFACE_TYPE_ARGB;
     
   combine = &_glitz_combine_map[src_type][mask_type];
-  if (combine->type == GLITZ_COMBINE_TYPE_NA) {
-    op->type = GLITZ_COMBINE_TYPE_INTERMEDIATE;
-    
+  if (!combine->type)
     return;
-  } 
   
   if (src_type == GLITZ_SURFACE_TYPE_SOLID) {
-    glitz_surface_ensure_solid (src);
+    glitz_surface_sync_solid (src);
     op->solid = &src->solid;
     op->src = NULL;
   }
   
   if (mask_type == GLITZ_SURFACE_TYPE_SOLID) {
-    glitz_surface_ensure_solid (mask);
+    glitz_surface_sync_solid (mask);
     op->alpha_mask = mask->solid;
     op->mask = NULL;
     op->combine = combine;
   } else if (mask_type == GLITZ_SURFACE_TYPE_SOLIDC) {
-    glitz_surface_ensure_solid (mask);
+    glitz_surface_sync_solid (mask);
     op->alpha_mask = mask->solid;
     op->mask = NULL;
     
     if (op->src) {
       op->per_component = 4;
       op->combine = combine;
-    } else if (dst->backend->feature_mask & GLITZ_FEATURE_BLEND_COLOR_MASK)
+    } else if (feature_mask & GLITZ_FEATURE_BLEND_COLOR_MASK)
       op->combine = combine;
     
   } else if (mask_type != GLITZ_SURFACE_TYPE_NULL) {
     if (mask_type == GLITZ_SURFACE_TYPE_ARGBC) {
       if (op->src) {
         op->per_component = 4;
-        if (dst->backend->feature_mask &
-            GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK)
+        if (feature_mask & GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK)
           op->combine = combine;
-      } else if (dst->backend->feature_mask & GLITZ_FEATURE_BLEND_COLOR_MASK)
+      } else if (feature_mask & GLITZ_FEATURE_BLEND_COLOR_MASK)
         op->combine = combine;
-    } else if (dst->backend->feature_mask &
-               GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK)
+    } else if (feature_mask & GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK)
       op->combine = combine;
   } else
     op->combine = combine;
 
-  if (!(dst->backend->feature_mask & GLITZ_FEATURE_MULTITEXTURE_MASK)) {
-    if (op->src && op->mask) {
-      if (!op->per_component) {
-        op->type = GLITZ_COMBINE_TYPE_INTERMEDIATE;
-        return;
-      } else
-        op->combine = NULL;
-    }
+  if (!(feature_mask & GLITZ_FEATURE_MULTITEXTURE_MASK)) {
+    if (op->src && op->mask)
+      op->combine = NULL;
   }
 
   if (op->per_component &&
-      (!(dst->backend->feature_mask &
-         GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK)))
+      (!(feature_mask & GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK)))
     op->combine = NULL;
   
   if (op->combine == combine) {
diff --git a/src/glitz_drawable.c b/src/glitz_drawable.c
new file mode 100644
index 0000000..f39b136
--- /dev/null
+++ b/src/glitz_drawable.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitzint.h"
+
+glitz_drawable_format_t *
+glitz_find_similar_drawable_format (glitz_drawable_t              *other,
+                                    unsigned long                 mask,
+                                    const glitz_drawable_format_t *templ,
+                                    int                           count)
+{
+  return glitz_drawable_format_find (other->backend->drawable_formats,
+                                     other->backend->n_drawable_formats,
+                                     mask, templ, count);
+}
+slim_hidden_def(glitz_find_similar_drawable_format);
+    
+glitz_drawable_t *
+glitz_create_pbuffer_drawable (glitz_drawable_t           *other,
+                               glitz_drawable_format_t    *format,
+                               glitz_pbuffer_attributes_t *attributes,
+                               unsigned long              mask)
+{
+  if (!format->types.pbuffer)
+    return NULL;
+  
+  return other->backend->create_pbuffer (other, format, attributes, mask);
+}
+slim_hidden_def(glitz_create_pbuffer_drawable);
+
+void
+glitz_drawable_destroy (glitz_drawable_t *drawable)
+{
+  if (!drawable)
+    return;
+
+  drawable->ref_count--;
+  if (drawable->ref_count)
+    return;
+  
+  drawable->backend->destroy (drawable);
+}
+
+void
+glitz_drawable_reference (glitz_drawable_t *drawable)
+{
+  if (drawable == NULL)
+    return;
+
+  drawable->ref_count++; 
+}
+
+void
+glitz_drawable_update_size (glitz_drawable_t *drawable,
+                            unsigned int     width,
+                            unsigned int     height)
+{
+  drawable->width = (int) width;
+  drawable->height = (int) height;
+
+  drawable->viewport.x = -32767;
+  drawable->viewport.y = -32767;
+  drawable->viewport.width = 65535;
+  drawable->viewport.height = 65535;
+
+  drawable->update_all = 1;
+}
+
+unsigned int
+glitz_drawable_get_width (glitz_drawable_t *drawable)
+{
+  return (unsigned int) drawable->width;
+}
+slim_hidden_def(glitz_drawable_get_width);
+
+unsigned int
+glitz_drawable_get_height (glitz_drawable_t *drawable)
+{
+  return (unsigned int) drawable->height;
+}
+slim_hidden_def(glitz_drawable_get_height);
+
+void
+glitz_drawable_swap_buffers (glitz_drawable_t *drawable)
+{
+  if (drawable->format->doublebuffer)
+    drawable->backend->swap_buffers (drawable);
+}
+slim_hidden_def(glitz_drawable_swap_buffers);
+
+void
+glitz_drawable_flush (glitz_drawable_t *drawable)
+{
+  drawable->backend->push_current (drawable, NULL, GLITZ_DRAWABLE_CURRENT);
+  drawable->backend->gl.flush ();
+  drawable->backend->pop_current (drawable);
+}
+slim_hidden_def(glitz_drawable_flush);
+
+void
+glitz_drawable_finish (glitz_drawable_t *drawable)
+{
+  drawable->backend->push_current (drawable, NULL, GLITZ_DRAWABLE_CURRENT);
+  drawable->backend->gl.finish ();
+  drawable->backend->pop_current (drawable);
+}
+slim_hidden_def(glitz_drawable_finish);
+
+unsigned long
+glitz_drawable_get_features (glitz_drawable_t *drawable)
+{
+  return drawable->backend->feature_mask;
+}
+slim_hidden_def(glitz_drawable_get_features);
+
+glitz_drawable_format_t *
+glitz_drawable_get_format (glitz_drawable_t *drawable)
+{
+  return drawable->format;
+}
+slim_hidden_def(glitz_drawable_get_format);
diff --git a/src/glitz_format.c b/src/glitz_format.c
index e9fc2c0..fd40532 100644
--- a/src/glitz_format.c
+++ b/src/glitz_format.c
@@ -1,28 +1,26 @@
 /*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
+ * Copyright © 2004 David Reveman
+ * 
  * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
  *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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.
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
+ * Author: David Reveman <c99drn@cs.umu.se>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -33,87 +31,115 @@
 
 #include <stdlib.h>
 
-static glitz_format_t _texture_formats[] = {
-  {
-    GLITZ_GL_ALPHA4, 0, 0, 0, 4, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_ALPHA8, 0, 0, 0, 8, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_ALPHA12, 0, 0, 0, 12, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_ALPHA16, 0, 0, 0, 16, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_R3_G3_B2, 3, 3, 2, 0, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB4, 4, 4, 4, 0, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB5, 5, 5, 5, 0, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB8, 8, 8, 8, 0, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB10, 10, 10, 10, 0, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB12, 12, 12, 12, 0, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB16, 16, 16, 16, 0, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGBA2, 2, 2, 2, 2, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB5_A1, 5, 5, 5, 1, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGBA8, 8, 8, 8, 8, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGB10_A2, 10, 10, 10, 2, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGBA12, 12, 12, 12, 12, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }, {
-    GLITZ_GL_RGBA16, 16, 16, 16, 16, 0, 0, 0, { 0, 1 }, { 0, 0 }, { 0, 0 }
-  }
+struct _texture_format {
+  glitz_gl_int_t texture_format;
+  glitz_format_t format;
+} _texture_formats[] = {
+  { GLITZ_GL_ALPHA4,   { 0, GLITZ_FORMAT_TYPE_COLOR, {  0,  0,  0,  4 } } },
+  { GLITZ_GL_ALPHA8,   { 0, GLITZ_FORMAT_TYPE_COLOR, {  0,  0,  0,  8 } } },
+  { GLITZ_GL_ALPHA12,  { 0, GLITZ_FORMAT_TYPE_COLOR, {  0,  0,  0, 12 } } },
+  { GLITZ_GL_ALPHA16,  { 0, GLITZ_FORMAT_TYPE_COLOR, {  0,  0,  0, 16 } } },
+  { GLITZ_GL_R3_G3_B2, { 0, GLITZ_FORMAT_TYPE_COLOR, {  3,  3,  2,  0 } } },
+  { GLITZ_GL_RGB4,     { 0, GLITZ_FORMAT_TYPE_COLOR, {  4,  4,  4,  0 } } },
+  { GLITZ_GL_RGB5,     { 0, GLITZ_FORMAT_TYPE_COLOR, {  5,  6,  5,  0 } } },
+  { GLITZ_GL_RGB8,     { 0, GLITZ_FORMAT_TYPE_COLOR, {  8,  8,  8,  0 } } },
+  { GLITZ_GL_RGB10,    { 0, GLITZ_FORMAT_TYPE_COLOR, { 10, 10, 10,  0 } } },
+  { GLITZ_GL_RGB12,    { 0, GLITZ_FORMAT_TYPE_COLOR, { 12, 12, 12,  0 } } },
+  { GLITZ_GL_RGB16,    { 0, GLITZ_FORMAT_TYPE_COLOR, { 16, 16, 16,  0 } } },
+  { GLITZ_GL_RGBA2,    { 0, GLITZ_FORMAT_TYPE_COLOR, {  2,  2,  2,  2 } } },
+  { GLITZ_GL_RGB5_A1,  { 0, GLITZ_FORMAT_TYPE_COLOR, {  5,  5,  5,  1 } } },
+  { GLITZ_GL_RGBA4,    { 0, GLITZ_FORMAT_TYPE_COLOR, {  4,  4,  4,  4 } } },
+  { GLITZ_GL_RGBA8,    { 0, GLITZ_FORMAT_TYPE_COLOR, {  8,  8,  8,  8 } } },
+  { GLITZ_GL_RGB10_A2, { 0, GLITZ_FORMAT_TYPE_COLOR, { 10, 10, 10,  2 } } },
+  { GLITZ_GL_RGBA12,   { 0, GLITZ_FORMAT_TYPE_COLOR, { 12, 12, 12, 12 } } },
+  { GLITZ_GL_RGBA16,   { 0, GLITZ_FORMAT_TYPE_COLOR, { 16, 16, 16, 16 } } }
 };
 
+static void
+_glitz_add_texture_format (glitz_format_t **formats,
+                           glitz_gl_int_t **texture_formats,
+                           int            *n_formats,
+                           glitz_gl_int_t texture_format,
+                           glitz_format_t *format)
+{
+  *formats = realloc (*formats, sizeof (glitz_format_t) * (*n_formats + 1));
+  *texture_formats = realloc (*texture_formats,
+                              sizeof (glitz_gl_enum_t) * (*n_formats + 1));
+
+  if (*formats && *texture_formats) {
+    (*texture_formats)[*n_formats] = texture_format;
+    (*formats)[*n_formats] = *format;
+    (*formats)[*n_formats].id = *n_formats;
+    (*n_formats)++;
+  } else
+    *n_formats = 0;
+}
+
 void
-glitz_format_for_each_texture_format (glitz_format_call_back_t call_back,
-				      glitz_gl_proc_address_list_t *gl,
-                                      void *ptr)
+glitz_create_surface_formats (glitz_gl_proc_address_list_t *gl,
+                              glitz_format_t               **formats,
+                              glitz_gl_int_t               **texture_formats,
+                              int                          *n_formats)
 {
   glitz_gl_int_t value;
-  int i, n_texture_formats =
-    sizeof (_texture_formats) / sizeof (glitz_format_t);
-
+  int i, n_texture_formats;
+  
+  n_texture_formats =
+    sizeof (_texture_formats) / sizeof (struct _texture_format);
+  
   for (i = 0; i < n_texture_formats; i++) {
     gl->tex_image_2d (GLITZ_GL_PROXY_TEXTURE_2D, 0,
-		      _texture_formats[i].id, 1, 1,
-		      0, GLITZ_GL_RGBA, GLITZ_GL_UNSIGNED_BYTE, NULL);
-    gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
-				    GLITZ_GL_TEXTURE_RED_SIZE, &value);
-    if (value != _texture_formats[i].red_size)
-      continue;
+                      _texture_formats[i].texture_format, 1, 1, 0,
+                      GLITZ_GL_RGBA, GLITZ_GL_UNSIGNED_BYTE, NULL);
 
-    gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
-				    GLITZ_GL_TEXTURE_GREEN_SIZE, &value);
-    if (value != _texture_formats[i].green_size)
-      continue;
+    switch (_texture_formats[i].format.type) {
+    case GLITZ_FORMAT_TYPE_COLOR:
+      if (_texture_formats[i].format.color.red_size) {
+        gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
+                                        GLITZ_GL_TEXTURE_RED_SIZE, &value);
+        if (value != _texture_formats[i].format.color.red_size)
+          continue;
+      }
+      
+      if (_texture_formats[i].format.color.green_size) {
+        gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
+                                        GLITZ_GL_TEXTURE_GREEN_SIZE, &value);
+        if (value != _texture_formats[i].format.color.green_size)
+          continue;
+      }
 
-    gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
-				    GLITZ_GL_TEXTURE_BLUE_SIZE, &value);
-    if (value != _texture_formats[i].blue_size)
-      continue;
+      if (_texture_formats[i].format.color.blue_size) {
+        gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
+                                        GLITZ_GL_TEXTURE_BLUE_SIZE, &value);
+        if (value != _texture_formats[i].format.color.blue_size)
+          continue;
+      }
 
-    gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
-				    GLITZ_GL_TEXTURE_ALPHA_SIZE, &value);
-    if (value != _texture_formats[i].alpha_size)
+      if (_texture_formats[i].format.color.alpha_size) {
+        gl->get_tex_level_parameter_iv (GLITZ_GL_PROXY_TEXTURE_2D, 0,
+                                        GLITZ_GL_TEXTURE_ALPHA_SIZE, &value);
+        if (value != _texture_formats[i].format.color.alpha_size)
+          continue;
+      }
+      break;
+    default:
       continue;
-
-    call_back (&_texture_formats[i], ptr);
+    }
+    
+    _glitz_add_texture_format (formats,
+                               texture_formats,
+                               n_formats,
+                               _texture_formats[i].texture_format,
+                               &_texture_formats[i].format);
   }
 }
 
-glitz_format_t *
-glitz_format_find (glitz_format_t *formats,
-                   int n_formats,
-                   unsigned long mask,
-                   const glitz_format_t *templ,
-                   int count)
+glitz_drawable_format_t *
+glitz_drawable_format_find (glitz_drawable_format_t       *formats,
+                            int                           n_formats,
+                            unsigned long                 mask,
+                            const glitz_drawable_format_t *templ,
+                            int                           count)
 {
   for (; n_formats; n_formats--, formats++) {
     if (mask & GLITZ_FORMAT_ID_MASK)
@@ -121,19 +147,19 @@ glitz_format_find (glitz_format_t *formats,
         continue;
 
     if (mask & GLITZ_FORMAT_RED_SIZE_MASK)
-      if (templ->red_size != formats->red_size)
+      if (templ->color.red_size != formats->color.red_size)
         continue;
 
     if (mask & GLITZ_FORMAT_GREEN_SIZE_MASK)
-      if (templ->green_size != formats->green_size)
+      if (templ->color.green_size != formats->color.green_size)
         continue;
 
     if (mask & GLITZ_FORMAT_BLUE_SIZE_MASK)
-      if (templ->blue_size != formats->blue_size)
+      if (templ->color.blue_size != formats->color.blue_size)
         continue;
 
     if (mask & GLITZ_FORMAT_ALPHA_SIZE_MASK)
-      if (templ->alpha_size != formats->alpha_size)
+      if (templ->color.alpha_size != formats->color.alpha_size)
         continue;
 
     if (mask & GLITZ_FORMAT_DEPTH_SIZE_MASK)
@@ -148,28 +174,55 @@ glitz_format_find (glitz_format_t *formats,
       if (templ->doublebuffer != formats->doublebuffer)
         continue;
 
-    if (mask & GLITZ_FORMAT_MULTISAMPLE_MASK)
-      if (templ->multisample.supported != formats->multisample.supported)
+    if (mask & GLITZ_FORMAT_SAMPLES_MASK)
+      if (templ->samples != formats->samples)
         continue;
 
-    if (mask & GLITZ_FORMAT_MULTISAMPLE_SAMPLES_MASK)
-      if (templ->multisample.samples != formats->multisample.samples)
+    if (mask & GLITZ_FORMAT_WINDOW_MASK)
+      if (templ->types.window != formats->types.window)
         continue;
 
-    if (mask & GLITZ_FORMAT_READ_ONSCREEN_MASK)
-      if (templ->read.onscreen != formats->read.onscreen)
+    if (mask & GLITZ_FORMAT_PBUFFER_MASK)
+      if (templ->types.pbuffer != formats->types.pbuffer)
         continue;
     
-    if (mask & GLITZ_FORMAT_READ_OFFSCREEN_MASK)
-      if (templ->read.offscreen != formats->read.offscreen)
+    if (count-- == 0)
+      return formats;    
+  }
+
+  return NULL;
+}
+
+static glitz_format_t *
+_glitz_format_find (glitz_format_t       *formats,
+                    int                  n_formats,
+                    unsigned long        mask,
+                    const glitz_format_t *templ,
+                    int                  count)
+{
+  for (; n_formats; n_formats--, formats++) {
+    if (mask & GLITZ_FORMAT_ID_MASK)
+      if (templ->id != formats->id)
         continue;
 
-    if (mask & GLITZ_FORMAT_DRAW_ONSCREEN_MASK)
-      if (templ->draw.onscreen != formats->draw.onscreen)
+    if (mask & GLITZ_FORMAT_TYPE_MASK)
+      if (templ->type != formats->type)
         continue;
-    
-    if (mask & GLITZ_FORMAT_DRAW_OFFSCREEN_MASK)
-      if (templ->draw.offscreen != formats->draw.offscreen)
+
+    if (mask & GLITZ_FORMAT_RED_SIZE_MASK)
+      if (templ->color.red_size != formats->color.red_size)
+        continue;
+
+    if (mask & GLITZ_FORMAT_GREEN_SIZE_MASK)
+      if (templ->color.green_size != formats->color.green_size)
+        continue;
+
+    if (mask & GLITZ_FORMAT_BLUE_SIZE_MASK)
+      if (templ->color.blue_size != formats->color.blue_size)
+        continue;
+
+    if (mask & GLITZ_FORMAT_ALPHA_SIZE_MASK)
+      if (templ->color.alpha_size != formats->color.alpha_size)
         continue;
 
     if (count-- == 0)
@@ -180,91 +233,53 @@ glitz_format_find (glitz_format_t *formats,
 }
 
 glitz_format_t *
-glitz_format_find_standard (glitz_format_t *formats,
-                            int n_formats,
+glitz_find_format (glitz_drawable_t     *drawable,
+                   unsigned long        mask,
+                   const glitz_format_t *templ,
+                   int                  count)
+{
+  return _glitz_format_find (drawable->backend->formats,
+                             drawable->backend->n_formats,
+                             mask, templ, count);
+}
+
+glitz_format_t *
+glitz_find_standard_format (glitz_drawable_t    *drawable,
                             glitz_format_name_t format_name)
 {
   glitz_format_t templ;
   unsigned long mask = GLITZ_FORMAT_RED_SIZE_MASK |
     GLITZ_FORMAT_GREEN_SIZE_MASK | GLITZ_FORMAT_BLUE_SIZE_MASK |
-    GLITZ_FORMAT_ALPHA_SIZE_MASK | GLITZ_FORMAT_READ_OFFSCREEN_MASK;
+    GLITZ_FORMAT_ALPHA_SIZE_MASK | GLITZ_FORMAT_TYPE_MASK;
 
-  /* only pick offscreen formats */
-  templ.read.offscreen = 1;
+  templ.type = GLITZ_FORMAT_TYPE_COLOR;
 
   switch (format_name) {
   case GLITZ_STANDARD_ARGB32:
-    templ.red_size = 8;
-    templ.green_size = 8;
-    templ.blue_size = 8;
-    templ.alpha_size = 8;
+    templ.color.red_size = 8;
+    templ.color.green_size = 8;
+    templ.color.blue_size = 8;
+    templ.color.alpha_size = 8;
     break;
   case GLITZ_STANDARD_RGB24:
-    templ.red_size = 8;
-    templ.green_size = 8;
-    templ.blue_size = 8;
-    templ.alpha_size = 0;
+    templ.color.red_size = 8;
+    templ.color.green_size = 8;
+    templ.color.blue_size = 8;
+    templ.color.alpha_size = 0;
     break;
   case GLITZ_STANDARD_A8:
-    templ.red_size = 0;
-    templ.green_size = 0;
-    templ.blue_size = 0;
-    templ.alpha_size = 8;
+    templ.color.red_size = 0;
+    templ.color.green_size = 0;
+    templ.color.blue_size = 0;
+    templ.color.alpha_size = 8;
     break;
   case GLITZ_STANDARD_A1:
-    templ.red_size = 0;
-    templ.green_size = 0;
-    templ.blue_size = 0;
-    templ.alpha_size = 1;
+    templ.color.red_size = 0;
+    templ.color.green_size = 0;
+    templ.color.blue_size = 0;
+    templ.color.alpha_size = 1;
     break;
   }
 
-  return glitz_format_find (formats, n_formats, mask, &templ, 0);
-}
-
-glitz_gl_int_t
-glitz_format_get_best_texture_format (glitz_format_t *formats,
-				      int n_formats,
-				      glitz_format_t *format)
-{
-  glitz_format_t templ;
-  unsigned long mask;
-  glitz_format_t *best_format, *texture_format;
-  int n_texture_formats =
-    sizeof (_texture_formats) / sizeof (glitz_format_t);
-  
-  if (format->draw.offscreen || format->draw.onscreen) {
-    unsigned int i = 0;
-  
-    templ.draw.offscreen = templ.draw.onscreen = 0;
-    templ.read.offscreen = 1;
-    mask = GLITZ_FORMAT_READ_OFFSCREEN_MASK | GLITZ_FORMAT_DRAW_ONSCREEN_MASK |
-      GLITZ_FORMAT_DRAW_OFFSCREEN_MASK;
-    
-    do {
-      best_format = glitz_format_find (formats, n_formats, mask, &templ, i++);
-      if (best_format &&
-          best_format->red_size >= format->red_size &&
-          best_format->green_size >= format->green_size &&
-          best_format->blue_size >= format->blue_size &&
-          best_format->alpha_size >= format->alpha_size)
-        break;
-    } while (best_format);
-    
-    if (!best_format)
-      return GLITZ_GL_RGBA;
-  } else
-    best_format = format;
-
-  mask = GLITZ_FORMAT_RED_SIZE_MASK | GLITZ_FORMAT_GREEN_SIZE_MASK | 
-    GLITZ_FORMAT_BLUE_SIZE_MASK | GLITZ_FORMAT_ALPHA_SIZE_MASK;
-  
-  texture_format =
-    glitz_format_find (_texture_formats, n_texture_formats,
-                       mask, best_format, 0);
-  
-  if (!texture_format)
-    return GLITZ_GL_RGBA;
-
-  return (glitz_gl_int_t) texture_format->id;
+  return glitz_find_format (drawable, mask, &templ, 0);
 }
diff --git a/src/glitz_geometry.c b/src/glitz_geometry.c
index 6952de5..733ccb6 100644
--- a/src/glitz_geometry.c
+++ b/src/glitz_geometry.c
@@ -99,25 +99,38 @@ static glitz_sample_info_t _1x_sample = {
 };
 
 void
-glitz_set_geometry (glitz_surface_t *dst,
-                    int x_dst,
-                    int y_dst,
+glitz_set_geometry (glitz_surface_t         *dst,
+                    glitz_fixed16_16_t      x_dst,
+                    glitz_fixed16_16_t      y_dst,
                     glitz_geometry_format_t *format,
-                    glitz_buffer_t *buffer)
+                    glitz_buffer_t          *buffer)
 {
-  if (dst->geometry.buffer) {
-    glitz_buffer_destroy (dst->geometry.buffer);
-    dst->geometry.buffer = NULL;
-  }
+  glitz_drawable_t *drawable = (dst->attached)? dst->attached: dst->drawable;
 
   if (buffer) {
-    dst->geometry.buffer = buffer;
     glitz_buffer_reference (buffer);
     
-    dst->geometry.x_offset = x_dst;
-    dst->geometry.y_offset = y_dst;
+    if (dst->geometry.buffer)
+      glitz_buffer_destroy (dst->geometry.buffer);
+
+    dst->geometry.buffer = buffer;
+    
+    dst->geometry.x_offset = FIXED_TO_FLOAT (x_dst);
+    dst->geometry.y_offset = FIXED_TO_FLOAT (y_dst);
 
     switch (format->primitive) {
+    case GLITZ_GEOMETRY_PRIMITIVE_POINTS:
+      dst->geometry.primitive = GLITZ_GL_POINTS;
+      break;
+    case GLITZ_GEOMETRY_PRIMITIVE_LINES:
+      dst->geometry.primitive = GLITZ_GL_LINES;
+      break;
+    case GLITZ_GEOMETRY_PRIMITIVE_LINE_STRIP:
+      dst->geometry.primitive = GLITZ_GL_LINE_STRIP;
+      break;
+    case GLITZ_GEOMETRY_PRIMITIVE_LINE_LOOP:
+      dst->geometry.primitive = GLITZ_GL_LINE_LOOP;
+      break;
     case GLITZ_GEOMETRY_PRIMITIVE_TRIANGLES:
       dst->geometry.primitive = GLITZ_GL_TRIANGLES;
       break;
@@ -156,7 +169,7 @@ glitz_set_geometry (glitz_surface_t *dst,
     dst->geometry.first = format->first;
     dst->geometry.count = format->count;
 
-    if (dst->format->multisample.samples > 1) {
+    if (drawable->format->samples > 1) {
       if (format->edge_hint != GLITZ_GEOMETRY_EDGE_HINT_SHARP) {
         dst->flags |= GLITZ_SURFACE_FLAG_MULTISAMPLE_MASK;
 
@@ -164,29 +177,25 @@ glitz_set_geometry (glitz_surface_t *dst,
           dst->flags |= GLITZ_SURFACE_FLAG_NICEST_MULTISAMPLE_MASK;
         else
           dst->flags &= ~GLITZ_SURFACE_FLAG_NICEST_MULTISAMPLE_MASK;
-        
-        dst->update_mask |= GLITZ_UPDATE_MULTISAMPLE_MASK;
-      } else {
+      } else
         dst->flags &= ~GLITZ_SURFACE_FLAG_MULTISAMPLE_MASK;
-        dst->update_mask |= GLITZ_UPDATE_MULTISAMPLE_MASK;
-      }
     } else {
       if (format->mode == GLITZ_GEOMETRY_MODE_INDIRECT) {
         switch (format->edge_hint) {
         case GLITZ_GEOMETRY_EDGE_HINT_BEST_SMOOTH:
-          if (dst->format->stencil_size >= 4) {
+          if (drawable->format->stencil_size >= 4) {
             dst->indirect = &_8x_multi_sample;
             break;
           }
           /* fall-through */
         case GLITZ_GEOMETRY_EDGE_HINT_GOOD_SMOOTH:
-          if (dst->format->stencil_size >= 3) {
+          if (drawable->format->stencil_size >= 3) {
             dst->indirect = &_4x_multi_sample;
             break;
           }
           /* fall-through */
         case GLITZ_GEOMETRY_EDGE_HINT_FAST_SMOOTH:
-          if (dst->format->stencil_size >= 2) {
+          if (drawable->format->stencil_size >= 2) {
             dst->indirect = &_2x_multi_sample;
             break;
           }
@@ -200,19 +209,20 @@ glitz_set_geometry (glitz_surface_t *dst,
         dst->indirect = NULL;
     }
   } else {
-    if (dst->format->multisample.samples > 1) {
-      dst->flags &= ~GLITZ_SURFACE_FLAG_MULTISAMPLE_MASK;
-      dst->update_mask |= GLITZ_UPDATE_MULTISAMPLE_MASK;
-    } else
-      dst->indirect = NULL;
+    if (dst->geometry.buffer)
+      glitz_buffer_destroy (dst->geometry.buffer);
+
+    dst->geometry.buffer = NULL;
+    dst->flags &= ~GLITZ_SURFACE_FLAG_MULTISAMPLE_MASK;
+    dst->indirect = NULL;
   }
 }
 slim_hidden_def(glitz_set_geometry);
 
 void
 glitz_geometry_enable_default (glitz_gl_proc_address_list_t *gl,
-                               glitz_surface_t *dst,
-                               glitz_bounding_box_t *box)
+                               glitz_surface_t              *dst,
+                               glitz_box_t                  *box)
 {
   dst->geometry.data[0] = box->x1;
   dst->geometry.data[1] = box->y1;
@@ -228,11 +238,11 @@ glitz_geometry_enable_default (glitz_gl_proc_address_list_t *gl,
 
 void
 glitz_geometry_enable (glitz_gl_proc_address_list_t *gl,
-                       glitz_surface_t *dst,
-                       glitz_gl_enum_t *primitive,
-                       glitz_gl_int_t *first,
-                       glitz_gl_sizei_t *count,
-                       glitz_bounding_box_t *box)
+                       glitz_surface_t              *dst,
+                       glitz_gl_enum_t              *primitive,
+                       glitz_gl_int_t               *first,
+                       glitz_gl_sizei_t             *count,
+                       glitz_box_t                  *box)
 {
   if (dst->geometry.buffer) {
     void *ptr;
@@ -257,9 +267,10 @@ glitz_geometry_enable (glitz_gl_proc_address_list_t *gl,
 
 void
 glitz_geometry_disable (glitz_gl_proc_address_list_t *gl,
-                        glitz_surface_t *dst)
+                        glitz_surface_t              *dst)
 {
   if (dst->geometry.buffer &&
-      (dst->backend->feature_mask & GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK))
+      (dst->drawable->backend->feature_mask &
+       GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK))
     gl->bind_buffer (GLITZ_GL_ARRAY_BUFFER, 0);
 }
diff --git a/src/glitz_gl.h b/src/glitz_gl.h
index 952cde3..4bdb544 100644
--- a/src/glitz_gl.h
+++ b/src/glitz_gl.h
@@ -53,6 +53,9 @@ typedef ptrdiff_t glitz_gl_sizeiptr_t;
 #define GLITZ_GL_NO_ERROR          0x0
 #define GLITZ_GL_INVALID_OPERATION 0x0502
 
+#define GLITZ_GL_VERSION                     0x1F02
+#define GLITZ_GL_EXTENSIONS                  0x1F03
+
 #define GLITZ_GL_UNSIGNED_BYTE               0x1401
 #define GLITZ_GL_FLOAT                       0x1406
 #define GLITZ_GL_UNSIGNED_BYTE_3_3_2         0x8032
@@ -75,6 +78,10 @@ typedef ptrdiff_t glitz_gl_sizeiptr_t;
 #define GLITZ_GL_FLOAT  0x1406
 #define GLITZ_GL_DOUBLE 0x140A
 
+#define GLITZ_GL_POINTS         0x0000
+#define GLITZ_GL_LINES          0x0001
+#define GLITZ_GL_LINE_LOOP      0x0002
+#define GLITZ_GL_LINE_STRIP     0x0003
 #define GLITZ_GL_TRIANGLES      0x0004
 #define GLITZ_GL_TRIANGLE_STRIP 0x0005
 #define GLITZ_GL_TRIANGLE_FAN   0x0006
@@ -88,6 +95,9 @@ typedef ptrdiff_t glitz_gl_sizeiptr_t;
 #define GLITZ_GL_FRONT          0x0404
 #define GLITZ_GL_BACK           0x0405
 #define GLITZ_GL_CULL_FACE      0x0B44
+
+#define GLITZ_GL_POINT_SMOOTH   0x0B10
+#define GLITZ_GL_LINE_SMOOTH    0x0B20
 #define GLITZ_GL_POLYGON_SMOOTH 0x0B41
 
 #define GLITZ_GL_SCISSOR_TEST 0x0C11
@@ -297,6 +307,8 @@ typedef glitz_gl_void_t (* glitz_gl_disable_t)
      (glitz_gl_enum_t cap);
 typedef glitz_gl_enum_t (* glitz_gl_get_error_t)
      (glitz_gl_void_t);
+typedef glitz_gl_ubyte_t *(* glitz_gl_get_string_t)
+     (glitz_gl_enum_t);
 typedef glitz_gl_void_t (* glitz_gl_enable_client_state_t)
      (glitz_gl_enum_t cap);
 typedef glitz_gl_void_t (* glitz_gl_disable_client_state_t)
diff --git a/src/glitz_glx_context.c b/src/glitz_glx_context.c
deleted file mode 100644
index 24c086d..0000000
--- a/src/glitz_glx_context.c
+++ /dev/null
@@ -1,435 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_glxint.h"
-
-#include <stdlib.h>
-
-extern glitz_gl_proc_address_list_t _glitz_glx_gl_proc_address;
-
-static void
-_glitz_glx_context_create (glitz_glx_screen_info_t *screen_info,
-                           XID visualid,
-                           GLXContext share_list,
-                           glitz_glx_context_t *context)
-{
-  int vis_info_count, i;
-  XVisualInfo *vis_infos;
-
-  vis_infos = XGetVisualInfo (screen_info->display_info->display,
-                              0, NULL, &vis_info_count);
-  for (i = 0; i < vis_info_count; i++) {
-    if (vis_infos[i].visual->visualid == visualid)
-      break;
-  }
-
-  context->context = glXCreateContext (screen_info->display_info->display,
-                                       &vis_infos[i], share_list,
-                                       GLITZ_GL_TRUE);
-  context->id = visualid;  
-  context->fbconfig = (XID) 0;
-
-  XFree (vis_infos);
-}
-
-static void
-_glitz_glx_context_create_fbconfig (glitz_glx_screen_info_t *screen_info,
-                                    XID fbconfigid,
-                                    GLXContext share_list,
-                                    glitz_glx_context_t *context)
-{
-  GLXFBConfig *fbconfigs;
-  int i, n_fbconfigs;
-  XVisualInfo *vinfo = NULL;
-  glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
-
-  fbconfigs = glx->get_fbconfigs (screen_info->display_info->display,
-                                  screen_info->screen, &n_fbconfigs);
-  for (i = 0; i < n_fbconfigs; i++) {
-    int value;
-    
-    glx->get_fbconfig_attrib (screen_info->display_info->display, fbconfigs[i],
-                              GLX_FBCONFIG_ID, &value);
-    if (value == (int) fbconfigid)
-      break;
-  }
-
-  if (i < n_fbconfigs)
-    vinfo = glx->get_visual_from_fbconfig (screen_info->display_info->display,
-                                           fbconfigs[i]);
-
-  context->id = fbconfigid;
-  if (vinfo) {
-    context->context = glXCreateContext (screen_info->display_info->display,
-                                         vinfo, share_list, GLITZ_GL_TRUE);
-    XFree (vinfo);
-  } else if (glx->create_new_context)
-    context->context =
-      glx->create_new_context (screen_info->display_info->display,
-                               fbconfigs[i], GLX_RGBA_TYPE, share_list,
-                               GLITZ_GL_TRUE);
-  
-  if (context->context)
-    context->fbconfig = fbconfigs[i];
-  else
-    context->fbconfig = NULL;
-
-  if (fbconfigs)
-    XFree (fbconfigs);
-}
-
-int
-glitz_glx_ensure_pbuffer_support (glitz_glx_screen_info_t *screen_info,
-                                  XID fbconfigid)
-{
-  GLXFBConfig *fbconfigs;
-  int i, n_fbconfigs;
-  glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
-  int status = 1;
-  
-  fbconfigs = glx->get_fbconfigs (screen_info->display_info->display,
-                                  screen_info->screen, &n_fbconfigs);
-  for (i = 0; i < n_fbconfigs; i++) {
-    int value;
-    
-    glx->get_fbconfig_attrib (screen_info->display_info->display, fbconfigs[i],
-                              GLX_FBCONFIG_ID, &value);
-    if (value == (int) fbconfigid)
-      break;
-  }
-  
-  if (i < n_fbconfigs) {
-    GLXPbuffer pbuffer;
-    glitz_texture_t texture;
-    
-    texture.width = texture.height = 1;
-    pbuffer = glitz_glx_pbuffer_create (screen_info, fbconfigs[i], &texture);
-    if (pbuffer) {
-      glitz_glx_pbuffer_destroy (screen_info, pbuffer);
-      
-      status = 0;
-    }
-  }
-
-  if (fbconfigs)
-    XFree (fbconfigs);
-  
-  return status;
-}
-
-glitz_glx_context_t *
-glitz_glx_context_get (glitz_glx_screen_info_t *screen_info,
-                       glitz_format_t *format)
-{
-  glitz_glx_context_t *context;
-  glitz_glx_context_t **contexts = screen_info->contexts;
-  int index, n_contexts = screen_info->n_contexts;
-
-  if (screen_info->format_ids[format->id] == (XID) 0)
-    return &screen_info->root_context;
-
-  for (; n_contexts; n_contexts--, contexts++)
-    if ((*contexts)->id == screen_info->format_ids[format->id])
-      return *contexts;
-
-  index = screen_info->n_contexts++;
-
-  screen_info->contexts =
-    realloc (screen_info->contexts,
-             sizeof (glitz_glx_context_t *) * screen_info->n_contexts);
-
-  context = malloc (sizeof (glitz_glx_context_t));
-  screen_info->contexts[index] = context;
-
-  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK)
-    _glitz_glx_context_create_fbconfig (screen_info,
-                                        screen_info->format_ids[format->id],
-                                        screen_info->root_context.context,
-                                        context);
-  else
-    _glitz_glx_context_create (screen_info,
-                               screen_info->format_ids[format->id],
-                               screen_info->root_context.context,
-                               context);
-
-  glitz_glx_surface_backend_init (&context->backend);
-
-  memcpy (&context->backend.gl,
-          &_glitz_glx_gl_proc_address,
-          sizeof (glitz_gl_proc_address_list_t));
-
-  context->backend.formats = screen_info->formats;
-  context->backend.n_formats = screen_info->n_formats;
-  context->backend.program_map = &screen_info->program_map;
-  context->backend.feature_mask = screen_info->feature_mask;
-  
-  context->backend.gl.need_lookup = 1;
-  
-  return context;
-}
-
-void
-glitz_glx_context_destroy (glitz_glx_screen_info_t *screen_info,
-                           glitz_glx_context_t *context)
-{
-  glXDestroyContext (screen_info->display_info->display,
-                     context->context);
-  free (context);
-}
-
-void
-glitz_glx_context_proc_address_lookup (glitz_glx_screen_info_t *screen_info,
-                                       glitz_glx_context_t *context)
-{
-  if (screen_info->feature_mask & GLITZ_FEATURE_BLEND_COLOR_MASK) {
-    if (screen_info->gl_version >= 1.4f) {
-      context->backend.gl.blend_color = (glitz_gl_blend_color_t)
-        glitz_glx_get_proc_address (screen_info, "glBlendColor");
-    } else {
-      context->backend.gl.blend_color = (glitz_gl_blend_color_t)
-        glitz_glx_get_proc_address (screen_info, "glBlendColorEXT");
-    }
-
-    if (!context->backend.gl.blend_color)
-      context->backend.feature_mask &= ~GLITZ_FEATURE_BLEND_COLOR_MASK;
-  }
-
-  if (screen_info->feature_mask & GLITZ_FEATURE_MULTITEXTURE_MASK) {
-    if (screen_info->gl_version >= 1.3f) {
-      context->backend.gl.active_texture = (glitz_gl_active_texture_t)
-        glitz_glx_get_proc_address (screen_info, "glActiveTexture");
-    } else {
-      context->backend.gl.active_texture = (glitz_gl_active_texture_t)
-        glitz_glx_get_proc_address (screen_info, "glActiveTextureARB");
-    }
-
-    if (!context->backend.gl.active_texture) {
-      context->backend.feature_mask &= ~GLITZ_FEATURE_MULTITEXTURE_MASK;
-      context->backend.feature_mask &=
-        ~GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK;
-    }
-  }
-
-  if (screen_info->feature_mask & GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK) {
-    context->backend.gl.gen_programs = (glitz_gl_gen_programs_t)
-      glitz_glx_get_proc_address (screen_info, "glGenProgramsARB");
-    context->backend.gl.delete_programs = (glitz_gl_delete_programs_t)
-      glitz_glx_get_proc_address (screen_info, "glDeleteProgramsARB");
-    context->backend.gl.program_string = (glitz_gl_program_string_t)
-      glitz_glx_get_proc_address (screen_info, "glProgramStringARB");
-    context->backend.gl.bind_program = (glitz_gl_bind_program_t)
-      glitz_glx_get_proc_address (screen_info, "glBindProgramARB");
-    context->backend.gl.program_local_param_4fv =
-      (glitz_gl_program_local_param_4fv_t)
-      glitz_glx_get_proc_address (screen_info,
-                                  "glProgramLocalParameter4fvARB");
-    context->backend.gl.get_program_iv = (glitz_gl_get_program_iv_t)
-      glitz_glx_get_proc_address (screen_info, "glGetProgramivARB");
-
-    if ((!context->backend.gl.gen_programs) ||
-        (!context->backend.gl.delete_programs) ||
-        (!context->backend.gl.program_string) ||
-        (!context->backend.gl.bind_program) ||
-        (!context->backend.gl.program_local_param_4fv))
-      context->backend.feature_mask &= ~GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK;
-  }
-
-  if ((screen_info->feature_mask & GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK) ||
-      (screen_info->feature_mask & GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK)) {
-    if (screen_info->gl_version >= 1.5f) {
-      context->backend.gl.gen_buffers = (glitz_gl_gen_buffers_t)
-        glitz_glx_get_proc_address (screen_info, "glGenBuffers");
-      context->backend.gl.delete_buffers = (glitz_gl_delete_buffers_t)
-        glitz_glx_get_proc_address (screen_info, "glDeleteBuffers");
-      context->backend.gl.bind_buffer = (glitz_gl_bind_buffer_t)
-        glitz_glx_get_proc_address (screen_info, "glBindBuffer");
-      context->backend.gl.buffer_data = (glitz_gl_buffer_data_t)
-        glitz_glx_get_proc_address (screen_info, "glBufferData");
-      context->backend.gl.buffer_sub_data = (glitz_gl_buffer_sub_data_t)
-        glitz_glx_get_proc_address (screen_info, "glBufferSubData");
-      context->backend.gl.get_buffer_sub_data =
-        (glitz_gl_get_buffer_sub_data_t)
-        glitz_glx_get_proc_address (screen_info, "glGetBufferSubData");
-      context->backend.gl.map_buffer = (glitz_gl_map_buffer_t)
-        glitz_glx_get_proc_address (screen_info, "glMapBuffer");
-      context->backend.gl.unmap_buffer = (glitz_gl_unmap_buffer_t)
-        glitz_glx_get_proc_address (screen_info, "glUnmapBuffer");
-    } else {
-      context->backend.gl.gen_buffers = (glitz_gl_gen_buffers_t)
-        glitz_glx_get_proc_address (screen_info, "glGenBuffersARB");
-      context->backend.gl.delete_buffers = (glitz_gl_delete_buffers_t)
-        glitz_glx_get_proc_address (screen_info, "glDeleteBuffersARB");
-      context->backend.gl.bind_buffer = (glitz_gl_bind_buffer_t)
-        glitz_glx_get_proc_address (screen_info, "glBindBufferARB");
-      context->backend.gl.buffer_data = (glitz_gl_buffer_data_t)
-        glitz_glx_get_proc_address (screen_info, "glBufferDataARB");
-      context->backend.gl.buffer_sub_data = (glitz_gl_buffer_sub_data_t)
-        glitz_glx_get_proc_address (screen_info, "glBufferSubDataARB");
-      context->backend.gl.get_buffer_sub_data =
-        (glitz_gl_get_buffer_sub_data_t)
-        glitz_glx_get_proc_address (screen_info, "glGetBufferSubDataARB");
-      context->backend.gl.map_buffer = (glitz_gl_map_buffer_t)
-        glitz_glx_get_proc_address (screen_info, "glMapBufferARB");
-      context->backend.gl.unmap_buffer = (glitz_gl_unmap_buffer_t)
-        glitz_glx_get_proc_address (screen_info, "glUnmapBufferARB");
-    }
-
-    if ((!context->backend.gl.gen_buffers) ||
-        (!context->backend.gl.delete_buffers) ||
-        (!context->backend.gl.bind_buffer) ||
-        (!context->backend.gl.buffer_data) ||
-        (!context->backend.gl.buffer_sub_data) ||
-        (!context->backend.gl.get_buffer_sub_data) ||
-        (!context->backend.gl.map_buffer) ||
-        (!context->backend.gl.unmap_buffer)) {
-      context->backend.feature_mask &=
-        ~GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK;
-      context->backend.feature_mask &= ~GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK;
-    }
-  }
-
-  context->backend.gl.get_integer_v (GLITZ_GL_MAX_VIEWPORT_DIMS,
-                                     context->max_viewport_dims);
-  context->backend.gl.get_integer_v (GLITZ_GL_MAX_TEXTURE_SIZE,
-                                     &context->max_texture_2d_size);
-
-  if (screen_info->feature_mask & GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK)
-    context->backend.gl.get_integer_v (GLITZ_GL_MAX_RECTANGLE_TEXTURE_SIZE,
-                                       &context->max_texture_rect_size);
-  else
-    context->max_texture_rect_size = 0;
-  
-  context->backend.gl.need_lookup = 0;
-}
-
-void
-glitz_glx_context_make_current (glitz_glx_surface_t *surface,
-                                GLXContext context,
-                                glitz_bool_t flush)
-{
-  Drawable drawable;
-
-  if (flush)
-    glFlush ();
-  
-  if (!surface->drawable) {
-    drawable = surface->screen_info->root_drawable;
-    context = surface->screen_info->root_context.context;
-  } else {
-    drawable = surface->drawable;
-    surface->base.update_mask |= GLITZ_UPDATE_ALL_MASK;
-  }
-  
-  glXMakeCurrent (surface->screen_info->display_info->display,
-                  drawable, context);
-
-  if (surface->context->backend.gl.need_lookup)
-    glitz_glx_context_proc_address_lookup (surface->screen_info,
-                                           surface->context);
-}
-
-static void
-glitz_glx_context_update (glitz_glx_surface_t *surface,
-                          glitz_constraint_t constraint)
-{
-  GLXContext context = glXGetCurrentContext ();
-  GLXContext newcontext;
-
-  if (surface->context->context)
-    newcontext = surface->context->context;
-  else
-    newcontext = surface->screen_info->root_context.context;
-  
-  switch (constraint) {
-  case GLITZ_CN_NONE:
-    break;
-  case GLITZ_CN_ANY_CONTEXT_CURRENT:
-    if (context == NULL)
-      glitz_glx_context_make_current (surface, newcontext, 0);
-    break;
-  case GLITZ_CN_SURFACE_CONTEXT_CURRENT:
-    if (context != newcontext)
-      glitz_glx_context_make_current (surface, newcontext, (context)? 1: 0);
-    break;
-  case GLITZ_CN_SURFACE_DRAWABLE_CURRENT:
-    if ((context != newcontext) ||
-        (glXGetCurrentDrawable () != surface->drawable))
-      glitz_glx_context_make_current (surface, newcontext, (context)? 1: 0);
-    break;
-  }
-}
-
-glitz_glx_surface_t *
-glitz_glx_context_push_current (glitz_glx_surface_t *surface,
-                                glitz_constraint_t constraint)
-{
-  glitz_glx_screen_info_t *screen_info;
-  glitz_glx_context_info_t *context_info;
-  int index;
-
-  screen_info = surface->screen_info;
-
-  index = screen_info->context_stack_size++;
-
-  context_info = &screen_info->context_stack[index];
-  context_info->surface = surface;
-  context_info->constraint = constraint;
-  
-  glitz_glx_context_update (context_info->surface, constraint);
-
-  if (context_info->constraint == GLITZ_CN_SURFACE_DRAWABLE_CURRENT)
-    return context_info->surface;
-  
-  return NULL;
-}
-
-glitz_glx_surface_t *
-glitz_glx_context_pop_current (glitz_glx_surface_t *surface)
-{
-  glitz_glx_screen_info_t *screen_info;
-  glitz_glx_context_info_t *context_info = NULL;
-  int index;
-
-  screen_info = surface->screen_info;
-
-  screen_info->context_stack_size--;
-  index = screen_info->context_stack_size - 1;
-
-  context_info = &screen_info->context_stack[index];
-
-  if (context_info->surface)
-    glitz_glx_context_update (context_info->surface, context_info->constraint);
-  
-  if (context_info->constraint == GLITZ_CN_SURFACE_DRAWABLE_CURRENT)
-    return context_info->surface;
-  
-  return NULL;
-}
diff --git a/src/glitz_glx_extension.c b/src/glitz_glx_extension.c
deleted file mode 100644
index 9f3ed50..0000000
--- a/src/glitz_glx_extension.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_glxint.h"
-
-static glitz_extension_map glx_extensions[] = {
-  { 0.0, "GLX_SGIX_fbconfig", GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK },
-  { 0.0, "GLX_SGIX_pbuffer", GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK },
-  { 0.0, "GLX_SGI_make_current_read",
-    GLITZ_GLX_FEATURE_GLX_MAKE_CURRENT_READ_MASK },
-  { 0.0, "GLX_ARB_multisample", GLITZ_GLX_FEATURE_GLX_MULTISAMPLE_MASK },
-  { 0.0, NULL, 0 }
-}, gl_extensions[] = {
-  { 0.0, "GL_ARB_texture_rectangle",
-    GLITZ_GLX_FEATURE_TEXTURE_RECTANGLE_MASK },
-  { 0.0, "GL_EXT_texture_rectangle",
-    GLITZ_GLX_FEATURE_TEXTURE_RECTANGLE_MASK },
-  { 0.0, "GL_NV_texture_rectangle", GLITZ_GLX_FEATURE_TEXTURE_RECTANGLE_MASK },
-  { 0.0, "GL_ARB_texture_non_power_of_two",
-    GLITZ_GLX_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK },
-  { 0.0, "GL_ARB_texture_mirrored_repeat",
-    GLITZ_GLX_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK },
-  { 0.0, "GL_ARB_texture_border_clamp",
-    GLITZ_GLX_FEATURE_TEXTURE_BORDER_CLAMP_MASK },
-  { 0.0, "GL_ARB_texture_env_combine",
-    GLITZ_GLX_FEATURE_TEXTURE_ENV_COMBINE_MASK },
-  { 0.0, "GL_EXT_texture_env_combine",
-    GLITZ_GLX_FEATURE_TEXTURE_ENV_COMBINE_MASK },
-  { 0.0, "GL_ARB_texture_env_dot3", GLITZ_GLX_FEATURE_TEXTURE_ENV_DOT3_MASK },
-  { 0.0, "GL_ARB_multisample", GLITZ_GLX_FEATURE_MULTISAMPLE_MASK },
-  { 0.0, "GL_NV_multisample_filter_hint",
-    GLITZ_GLX_FEATURE_MULTISAMPLE_FILTER_HINT_MASK },
-  { 0.0, "GL_ARB_multitexture", GLITZ_GLX_FEATURE_MULTITEXTURE_MASK },
-  { 0.0, "GL_ARB_fragment_program", GLITZ_GLX_FEATURE_FRAGMENT_PROGRAM_MASK },
-  { 0.0, "GL_ARB_vertex_buffer_object",
-    GLITZ_GLX_FEATURE_VERTEX_BUFFER_OBJECT_MASK },
-  { 0.0, "GL_EXT_pixel_buffer_object",
-    GLITZ_GLX_FEATURE_PIXEL_BUFFER_OBJECT_MASK },
-  { 0.0, "GL_EXT_blend_color",
-    GLITZ_GLX_FEATURE_BLEND_COLOR_MASK },
-  { 0.0, "GL_ARB_imaging",
-    GLITZ_GLX_FEATURE_BLEND_COLOR_MASK },
-  { 0.0, NULL, 0 }
-};
-
-static unsigned long
-_glitz_glx_extension_query_glx (Display *display,
-                                int screen,
-                                glitz_gl_float_t glx_version)
-{
-  const char *glx_extensions_string;
-  
-  glx_extensions_string = glXQueryExtensionsString (display, screen);
-  
-  return glitz_extensions_query (glx_version,
-                                 glx_extensions_string,
-                                 glx_extensions);
-}
-
-static unsigned long
-_glitz_glx_extension_query_gl (glitz_gl_float_t gl_version)
-{
-  const char *gl_extensions_string;
-  
-  gl_extensions_string = (const char *) glGetString (GL_EXTENSIONS);
-
-  return glitz_extensions_query (gl_version,
-                                 gl_extensions_string,
-                                 gl_extensions);
-}
-
-glitz_status_t
-glitz_glx_query_extensions (glitz_glx_screen_info_t *screen_info)
-{
-  screen_info->gl_version = atof ((const char *) glGetString (GL_VERSION));
-  if (screen_info->gl_version < 1.2f)
-    return GLITZ_STATUS_NOT_SUPPORTED;
-  
-  screen_info->glx_feature_mask |=
-    _glitz_glx_extension_query_glx (screen_info->display_info->display,
-                                    screen_info->screen,
-                                    screen_info->glx_version);
-  
-  screen_info->glx_feature_mask |=
-    _glitz_glx_extension_query_gl (screen_info->gl_version);
-
-  if ((screen_info->glx_feature_mask &
-       GLITZ_GLX_FEATURE_GLX_MULTISAMPLE_MASK) &&
-      (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTISAMPLE_MASK)) {
-    const glitz_gl_ubyte_t *renderer = glGetString (GL_RENDERER);
-    
-    screen_info->feature_mask |= GLITZ_FEATURE_MULTISAMPLE_MASK;
-    
-    if (screen_info->glx_feature_mask &
-        GLITZ_GLX_FEATURE_MULTISAMPLE_FILTER_HINT_MASK)
-      screen_info->feature_mask |= GLITZ_FEATURE_MULTISAMPLE_FILTER_HINT_MASK;
-    
-    if (renderer) {
-      /* All geforce and quadro cards seems to support multisample with
-         pbuffers */
-      if (!strncmp ("GeForce", renderer, 7))
-        screen_info->feature_mask |= GLITZ_FEATURE_OFFSCREEN_MULTISAMPLE_MASK;
-      else if (!strncmp ("Quadro", renderer, 6))
-        screen_info->feature_mask |= GLITZ_FEATURE_OFFSCREEN_MULTISAMPLE_MASK;
-    }
-  }
-
-  if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_TEXTURE_RECTANGLE_MASK)
-    screen_info->feature_mask |= GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK;
-  
-  if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK)
-    screen_info->feature_mask |= GLITZ_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK;
-
-  if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK)
-    screen_info->feature_mask |= GLITZ_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK;
-
-  if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_TEXTURE_BORDER_CLAMP_MASK)
-    screen_info->feature_mask |= GLITZ_FEATURE_TEXTURE_BORDER_CLAMP_MASK;
-
-  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTITEXTURE_MASK) {
-    screen_info->feature_mask |= GLITZ_FEATURE_MULTITEXTURE_MASK;
-
-    if (screen_info->glx_feature_mask &
-        GLITZ_GLX_FEATURE_TEXTURE_ENV_COMBINE_MASK)
-      screen_info->feature_mask |= GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK;
-    
-    if (screen_info->glx_feature_mask &
-        GLITZ_GLX_FEATURE_TEXTURE_ENV_DOT3_MASK)
-      screen_info->feature_mask |= GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK;
-      
-    if ((screen_info->feature_mask & GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK) &&
-        (screen_info->feature_mask & GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK)) {
-      glitz_gl_int_t max_texture_units;
-      
-      glGetIntegerv (GLITZ_GL_MAX_TEXTURE_UNITS, &max_texture_units);
-      if (max_texture_units >= 3)
-        screen_info->feature_mask |=
-          GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK;
-    }
-        
-    if (screen_info->glx_feature_mask &
-        GLITZ_GLX_FEATURE_FRAGMENT_PROGRAM_MASK)
-      screen_info->feature_mask |= GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK;
-  }
-
-  if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_VERTEX_BUFFER_OBJECT_MASK)
-    screen_info->feature_mask |= GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK;
-
-  if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_PIXEL_BUFFER_OBJECT_MASK)
-    screen_info->feature_mask |= GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK;
-
-  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_BLEND_COLOR_MASK)
-    screen_info->feature_mask |= GLITZ_FEATURE_BLEND_COLOR_MASK;
-
-  return GLITZ_STATUS_SUCCESS;
-}
diff --git a/src/glitz_glx_format.c b/src/glitz_glx_format.c
deleted file mode 100644
index 7858e04..0000000
--- a/src/glitz_glx_format.c
+++ /dev/null
@@ -1,371 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_glxint.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-static int
-_glitz_glx_format_compare (const void *elem1,
-                           const void *elem2)
-{
-  int i, score[2];
-  glitz_format_t *format[2];
-  
-  format[0] = (glitz_format_t *) elem1;
-  format[1] = (glitz_format_t *) elem2;
-  i = score[0] = score[1] = 0;
-
-  for (; i < 2; i++) {
-    if (format[i]->red_size)
-      score[i] += 10;
-    if (format[i]->alpha_size)
-      score[i] += 10;
-    if (format[i]->stencil_size)
-      score[i] += (10 + format[i]->stencil_size);
-    if (format[i]->doublebuffer)
-      score[i] -= 10;
-    if (format[i]->draw.onscreen)
-      score[i] += 5;
-    if (format[i]->draw.offscreen)
-      score[i] += 5;
-    if (format[i]->draw.offscreen && format[i]->draw.onscreen)
-      score[i] += 5;
-    if (format[i]->multisample.supported) 
-      score[i] -= (10 - format[i]->multisample.samples);
-  }
-  
-  return score[1] - score[0];
-}
-
-static void
-_glitz_add_format (glitz_glx_screen_info_t *screen_info,
-                   glitz_format_t *format)
-{
-  if (!glitz_format_find (screen_info->formats, screen_info->n_formats,
-                          GLITZ_FORMAT_ALL_EXCEPT_ID_MASK, format, 0)) {
-    int index = screen_info->n_formats++;
-
-    screen_info->formats =
-      realloc (screen_info->formats,
-               sizeof (glitz_format_t) * screen_info->n_formats);
-
-    screen_info->formats[index] = *format;
-  }
-}
-
-static void
-_glitz_move_out_ids (glitz_glx_screen_info_t *screen_info)
-{
-  int i;
-  glitz_format_t *formats = screen_info->formats;
-  int n_formats = screen_info->n_formats;
-
-  screen_info->format_ids = malloc (sizeof (XID) * n_formats);
-  
-  for (i = 0; n_formats; n_formats--, formats++) {
-    screen_info->format_ids[i] = formats->id;
-    formats->id = i++;
-  }
-}
-
-static void
-_glitz_glx_query_formats (glitz_glx_screen_info_t *screen_info)
-{
-  Display *display;
-  glitz_format_t format;
-  XVisualInfo visual_templ;
-  XVisualInfo *visuals;
-  int i, num_visuals;
-  
-  display = screen_info->display_info->display;
-
-  visual_templ.screen = screen_info->screen;
-  visuals = XGetVisualInfo (display, VisualScreenMask,
-                            &visual_templ, &num_visuals);
-
-  /* Offscreen drawing never supported without fbconfigs */
-  format.draw.offscreen = format.read.offscreen = 0;
-  format.draw.onscreen = format.read.onscreen = 1;
-
-  for (i = 0; i < num_visuals; i++) {
-    int value;
-    
-    if ((glXGetConfig (display, &visuals[i], GLX_USE_GL, &value) != 0) ||
-        (value == 0))
-      continue;
-    
-    glXGetConfig (display, &visuals[i], GLX_RGBA, &value);
-    if (value == 0)
-      continue;
-
-    /* Stereo is not supported yet */
-    glXGetConfig (display, &visuals[i], GLX_STEREO, &value);
-    if (value != 0)
-      continue;
-    
-    format.id = visuals[i].visualid;
-    glXGetConfig (display, &visuals[i], GLX_RED_SIZE, &value);
-    format.red_size = (unsigned short) value;
-    glXGetConfig (display, &visuals[i], GLX_GREEN_SIZE, &value);
-    format.green_size = (unsigned short) value;
-    glXGetConfig (display, &visuals[i], GLX_BLUE_SIZE, &value);
-    format.blue_size = (unsigned short) value;
-    glXGetConfig (display, &visuals[i], GLX_ALPHA_SIZE, &value);
-    format.alpha_size = (unsigned short) value;
-    glXGetConfig (display, &visuals[i], GLX_DEPTH_SIZE, &value);
-    format.depth_size = (unsigned short) value;
-    glXGetConfig (display, &visuals[i], GLX_STENCIL_SIZE, &value);
-    format.stencil_size = (unsigned short) value;
-    glXGetConfig (display, &visuals[i], GLX_DOUBLEBUFFER, &value);
-    format.doublebuffer = (value) ? 1: 0;
-
-    if (screen_info->feature_mask & GLITZ_FEATURE_MULTISAMPLE_MASK) {
-      glXGetConfig (display, &visuals[i], GLX_SAMPLE_BUFFERS_ARB, &value);
-      format.multisample.supported = (value) ? 1: 0;
-      glXGetConfig (display, &visuals[i], GLX_SAMPLES_ARB, &value);
-      format.multisample.samples = (unsigned short) value;
-    } else {
-      format.multisample.supported = 0;
-      format.multisample.samples = 0;
-    }
-
-    if (format.red_size || format.green_size || format.blue_size ||
-        format.alpha_size)
-      _glitz_add_format (screen_info, &format);
-  }
-  
-  if (visuals)
-    XFree (visuals);
-}
-
-static glitz_bool_t
-_glitz_glx_query_formats_fbconfig (glitz_glx_screen_info_t *screen_info)
-{
-  Display *display;
-  glitz_format_t format;
-  GLXFBConfig *fbconfigs;
-  int i, num_configs, pbuffer_support, pbuffer_check = 1;
-  glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
-  
-  display = screen_info->display_info->display;
-
-  fbconfigs = glx->get_fbconfigs (display, screen_info->screen, &num_configs);
-  if (!fbconfigs) {
-    /* fbconfigs are not support, falling back to visuals */
-    screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK;
-    screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK;
-    return 1;
-  }
-
-  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK)
-    pbuffer_support = 1;
-  else
-    pbuffer_support = 0;
-  
-  for (i = 0; i < num_configs; i++) {
-    int value;
-    
-    if ((glx->get_fbconfig_attrib (display, fbconfigs[i],
-                                   GLX_RENDER_TYPE, &value) != 0) ||
-        (!(value & GLX_RGBA_BIT)))
-      continue;
-
-    /* Stereo is not supported yet */
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_STEREO, &value);
-    if (value != 0)
-      continue;
-
-    glx->get_fbconfig_attrib (display, fbconfigs[i],
-                              GLX_DRAWABLE_TYPE, &value);
-    if (!((value & GLX_WINDOW_BIT) || (value & GLX_PBUFFER_BIT)))
-      continue;
-    
-    format.read.onscreen = format.draw.onscreen =
-      (value & GLX_WINDOW_BIT)? 1: 0;
-    format.read.offscreen = format.draw.offscreen =
-      (pbuffer_support && (value & GLX_PBUFFER_BIT))? 1: 0;
-    
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_FBCONFIG_ID, &value);
-    format.id = (XID) value;
-
-    if (pbuffer_check && format.draw.offscreen) {
-      if (glitz_glx_ensure_pbuffer_support (screen_info, format.id)) {
-	pbuffer_support = 0;
-	format.draw.offscreen = 0;
-      }
-      pbuffer_check = 0;
-    }
-    
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_RED_SIZE, &value);
-    format.red_size = (unsigned short) value;
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_GREEN_SIZE, &value);
-    format.green_size = (unsigned short) value;
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_BLUE_SIZE, &value);
-    format.blue_size = (unsigned short) value;
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_ALPHA_SIZE, &value);
-    format.alpha_size = (unsigned short) value;
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_DEPTH_SIZE, &value);
-    format.depth_size = (unsigned short) value;
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_STENCIL_SIZE, &value);
-    format.stencil_size = (unsigned short) value;
-    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_DOUBLEBUFFER, &value);
-    format.doublebuffer = (value)? 1: 0;
-    
-    if (screen_info->feature_mask & GLITZ_FEATURE_MULTISAMPLE_MASK) {
-      glx->get_fbconfig_attrib (display, fbconfigs[i],
-                                GLX_SAMPLE_BUFFERS_ARB, &value);
-      format.multisample.supported = (value)? 1: 0;
-      glx->get_fbconfig_attrib (display, fbconfigs[i],
-                                GLX_SAMPLES_ARB, &value);
-      format.multisample.samples = (unsigned short) value;
-    } else {
-      format.multisample.supported = 0;
-      format.multisample.samples = 0;
-    }
-
-    if (format.red_size || format.green_size || format.blue_size ||
-        format.alpha_size)
-      _glitz_add_format (screen_info, &format);
-  }
-  
-  if (fbconfigs)
-    XFree (fbconfigs);
-
-  return 0;
-}
-
-static void
-_glitz_glx_add_texture_format (glitz_format_t *texture_format, void *ptr)
-{
-  glitz_glx_screen_info_t *screen_info = (glitz_glx_screen_info_t *) ptr;
-  glitz_format_t format;
-
-  format = *texture_format;
-  format.id = 0;
-
-  _glitz_add_format (screen_info, &format);
-}
-
-void
-glitz_glx_query_formats (glitz_glx_screen_info_t *screen_info)
-{
-  glitz_bool_t status = 1;
-
-  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK)
-    status = _glitz_glx_query_formats_fbconfig (screen_info);
-
-  if (status)
-    _glitz_glx_query_formats (screen_info);
-
-  qsort (screen_info->formats, screen_info->n_formats, 
-         sizeof (glitz_format_t), _glitz_glx_format_compare);
- 
-  glitz_format_for_each_texture_format (&_glitz_glx_add_texture_format,
-					&screen_info->root_context.backend.gl,
-					(void *) screen_info);
-  
-  _glitz_move_out_ids (screen_info);
-}
-
-glitz_format_t *
-glitz_glx_find_format (Display *display,
-                       int screen,
-                       unsigned long mask,
-                       const glitz_format_t *templ,
-                       int count)
-{
-  glitz_glx_screen_info_t *screen_info =
-    glitz_glx_screen_info_get (display, screen);
-
-  return glitz_format_find (screen_info->formats, screen_info->n_formats,
-                            mask, templ, count);
-}
-slim_hidden_def(glitz_glx_find_format);
-
-glitz_format_t *
-glitz_glx_find_standard_format (Display *display,
-                                int screen,
-                                glitz_format_name_t format_name)
-{
-  glitz_glx_screen_info_t *screen_info =
-    glitz_glx_screen_info_get (display, screen);
-
-  return
-    glitz_format_find_standard (screen_info->formats, screen_info->n_formats,
-                                format_name);
-}
-slim_hidden_def(glitz_glx_find_standard_format);
-
-XVisualInfo *
-glitz_glx_get_visual_info_from_format (Display *display,
-                                       int screen,
-                                       glitz_format_t *format)
-{
-  XVisualInfo *vinfo = NULL;
-  glitz_glx_screen_info_t *screen_info =
-    glitz_glx_screen_info_get (display, screen);
-  glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
-
-  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK) {
-    GLXFBConfig *fbconfigs;
-    int i, n_fbconfigs;
-    int fbconfigid = screen_info->format_ids[format->id];
-
-    fbconfigs = glx->get_fbconfigs (display, screen, &n_fbconfigs);
-    for (i = 0; i < n_fbconfigs; i++) {
-      int value;
-      
-      glx->get_fbconfig_attrib (display, fbconfigs[i],
-                                GLX_FBCONFIG_ID, &value);
-      if (value == fbconfigid)
-        break;
-    }
-    
-    if (i < n_fbconfigs)
-      vinfo = glx->get_visual_from_fbconfig (display, fbconfigs[i]);
-    
-    if (fbconfigs)
-      XFree (fbconfigs);
-    
-  } else {
-    XVisualInfo templ;
-    int n_items;
-    
-    templ.visualid = screen_info->format_ids[format->id];
-    
-    vinfo = XGetVisualInfo (display, VisualIDMask, &templ, &n_items);
-  }
-  
-  return vinfo;
-}
-slim_hidden_def(glitz_glx_get_visual_info_from_format);
diff --git a/src/glitz_glx_pbuffer.c b/src/glitz_glx_pbuffer.c
deleted file mode 100644
index e311473..0000000
--- a/src/glitz_glx_pbuffer.c
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_glxint.h"
-
-GLXPbuffer
-glitz_glx_pbuffer_create (glitz_glx_screen_info_t *screen_info,
-                          GLXFBConfig fbconfig,
-                          glitz_texture_t *texture)
-{
-  if (fbconfig) {
-    int pbuffer_attr[13], i = 0;
-
-    pbuffer_attr[i++] = GLX_PBUFFER_WIDTH;
-    pbuffer_attr[i++] = texture->width;
-    pbuffer_attr[i++] = GLX_PBUFFER_HEIGHT;
-    pbuffer_attr[i++] = texture->height;
-    pbuffer_attr[i++] = GLX_PRESERVED_CONTENTS;
-    pbuffer_attr[i++] = 1;
-    pbuffer_attr[i++] = GLX_LARGEST_PBUFFER;
-    pbuffer_attr[i++] = 0;
-    pbuffer_attr[i++] = 0;
-
-    return
-      screen_info->glx.create_pbuffer (screen_info->display_info->display,
-                                       fbconfig, pbuffer_attr);
-  } else
-    return (GLXPbuffer) 0;
-}
-
-void 
-glitz_glx_pbuffer_destroy (glitz_glx_screen_info_t *screen_info,
-                           GLXPbuffer pbuffer)
-{
-  screen_info->glx.destroy_pbuffer (screen_info->display_info->display,
-                                    pbuffer);
-}
diff --git a/src/glitz_glx_surface.c b/src/glitz_glx_surface.c
deleted file mode 100644
index e4d4f93..0000000
--- a/src/glitz_glx_surface.c
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "../config.h"
-#endif
-
-#include "glitz_glxint.h"
-
-static glitz_bool_t
-_glitz_glx_surface_push_current (void *abstract_surface,
-                                 glitz_constraint_t constraint)
-{
-  glitz_glx_surface_t *surface = (glitz_glx_surface_t *) abstract_surface;
-  glitz_bool_t success = 1;
-
-  if (constraint == GLITZ_CN_SURFACE_DRAWABLE_CURRENT &&
-      (!surface->drawable)) {
-    if (surface->base.format->draw.offscreen) {
-      surface->drawable = surface->pbuffer =
-        glitz_glx_pbuffer_create (surface->screen_info,
-                                  surface->context->fbconfig,
-                                  &surface->base.texture);
-    } else {
-      constraint = GLITZ_CN_ANY_CONTEXT_CURRENT;
-      success = 0;
-    }
-  }
-  
-  surface = glitz_glx_context_push_current (surface, constraint);
-
-  if (surface) {
-    glitz_surface_update_state (&surface->base);
-    return 1;
-  }
-
-  return success;
-}
-
-static void
-_glitz_glx_surface_pop_current (void *abstract_surface)
-{
-  glitz_glx_surface_t *surface = (glitz_glx_surface_t *) abstract_surface;
-
-  surface = glitz_glx_context_pop_current (surface);
-  
-  if (surface)
-    glitz_surface_update_state (&surface->base);
-}
-
-static glitz_bool_t
-_glitz_glx_surface_make_current_read (void *abstract_surface)
-{
-  /* This doesn't seem to work.
-  glitz_glx_surface_t *surface = (glitz_glx_surface_t *) abstract_surface;
-  glitz_glx_static_proc_address_list_t *glx =
-    &surface->screen_info->display_info->thread_info->glx;
-  
-  if ((screen_info->glx_feature_mask &
-       GLITZ_GLX_FEATURE_GLX_MAKE_CURRENT_READ_MASK) && surface->drawable) {
-    GLXContext context = glXGetCurrentContext ();
-    
-    if (context == surface->context->context)
-      return
-        glx->make_context_current (surface->screen_info->display_info->display,
-                                   glXGetCurrentDrawable (),
-                                   surface->drawable,
-                                   context);
-  }
-  */
-
-  return 0;
-}
-
-static glitz_texture_t *
-_glitz_glx_surface_get_texture (void *abstract_surface,
-                                glitz_bool_t allocate)
-{
-  glitz_glx_surface_t *surface = (glitz_glx_surface_t *) abstract_surface;
-  
-  if (surface->base.flags & GLITZ_SURFACE_FLAG_DIRTY_MASK) {
-    glitz_bounding_box_t copy_box;
-
-    copy_box.x1 = copy_box.y1 = 0;
-    copy_box.x2 = surface->base.width;
-    copy_box.y2 = surface->base.height;
-    glitz_intersect_bounding_box (&surface->base.dirty_box,
-                                  &copy_box, &copy_box);
-
-    if (!(TEXTURE_ALLOCATED (&surface->base.texture)))
-      glitz_texture_allocate (&surface->base.backend->gl,
-                              &surface->base.texture);  
-      
-    glitz_texture_copy_surface (&surface->base.texture, &surface->base,
-                                copy_box.x1,
-                                copy_box.y1,
-                                copy_box.x2 - copy_box.x1,
-                                copy_box.y2 - copy_box.y1,
-                                copy_box.x1,
-                                copy_box.y1);
-    
-    surface->base.flags &= ~GLITZ_SURFACE_FLAG_DIRTY_MASK;
-  }
-
-  if (allocate) {
-    if (!(TEXTURE_ALLOCATED (&surface->base.texture)))
-      glitz_texture_allocate (&surface->base.backend->gl,
-                              &surface->base.texture);
-  }
-  
-  if (TEXTURE_ALLOCATED (&surface->base.texture))
-    return &surface->base.texture;
-  else
-    return NULL;
-}
-
-static glitz_surface_t *
-_glitz_glx_surface_create (glitz_glx_screen_info_t *screen_info,
-                           glitz_format_t *format,
-                           int width,
-                           int height)
-{
-  glitz_glx_surface_t *surface;
-  glitz_glx_context_t *context;
-
-  if (width <= 0 || height <= 0)
-    return NULL;
-
-  context = glitz_glx_context_get (screen_info, format);
-  if (!context)
-    return NULL;
-  
-  surface = (glitz_glx_surface_t *) calloc (1, sizeof (glitz_glx_surface_t));
-  if (surface == NULL)
-    return NULL;
-
-  glitz_surface_init (&surface->base,
-                      &context->backend,
-                      format,
-                      width,
-                      height);
-  
-  surface->screen_info = screen_info;
-  surface->context = context;
-  
-  surface->base.flags |= GLITZ_SURFACE_FLAG_OFFSCREEN_MASK;
-
-  if (format->draw.offscreen)
-    surface->base.flags |= GLITZ_SURFACE_FLAG_DRAWABLE_MASK;
-
-  if (surface->context->backend.gl.need_lookup) {
-    glitz_glx_context_push_current (surface, GLITZ_CN_SURFACE_CONTEXT_CURRENT);
-    glitz_glx_context_pop_current (surface);
-  }
-
-  if (width > 64 || height > 64) {
-    glitz_glx_context_push_current (surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
-    glitz_texture_size_check (&surface->base.backend->gl,
-                              &surface->base.texture,
-                              context->max_texture_2d_size,
-                              context->max_texture_rect_size);
-    glitz_glx_context_pop_current (surface);
-    if (TEXTURE_INVALID_SIZE (&surface->base.texture) ||
-        (format->draw.offscreen &&
-         ((width > context->max_viewport_dims[0]) ||
-          (height > context->max_viewport_dims[1])))) {
-      glitz_surface_destroy (&surface->base);
-      return NULL;
-    }
-  }
-
-  return &surface->base;
-}
-
-glitz_surface_t *
-glitz_glx_surface_create (Display *display,
-                          int screen,
-                          glitz_format_t *format,
-                          int width,
-                          int height)
-{
-  glitz_glx_screen_info_t *screen_info;
-
-  screen_info = glitz_glx_screen_info_get (display, screen);
-  if (!screen_info)
-    return NULL;
-  
-  return _glitz_glx_surface_create (screen_info, format, width, height);
-}
-slim_hidden_def(glitz_glx_surface_create);
-
-glitz_surface_t *
-glitz_glx_surface_create_for_window (Display *display,
-                                     int screen,
-                                     glitz_format_t *format,
-                                     Window window,
-                                     int width,
-                                     int height)
-{
-  glitz_glx_surface_t *surface;
-  glitz_glx_context_t *context;
-  glitz_glx_screen_info_t *screen_info;
-
-  if (width <= 0 || height <= 0)
-    return NULL;
-
-  screen_info = glitz_glx_screen_info_get (display, screen);
-  if (!screen_info)
-    return NULL;
-  
-  context = glitz_glx_context_get (screen_info, format);
-  if (!context)
-    return NULL;
-
-  surface = (glitz_glx_surface_t *) calloc (1, sizeof (glitz_glx_surface_t));
-  if (surface == NULL)
-    return NULL;
-
-  glitz_surface_init (&surface->base,
-                      &context->backend,
-                      format,
-                      width,
-                      height);
-  
-  surface->screen_info = screen_info;
-  surface->context = context;
-  surface->drawable = window;
-
-  surface->base.flags |= GLITZ_SURFACE_FLAG_DRAWABLE_MASK;
-
-  if (surface->context->backend.gl.need_lookup) {
-    glitz_glx_context_push_current (surface, GLITZ_CN_SURFACE_CONTEXT_CURRENT);
-    glitz_glx_context_pop_current (surface);
-  }
-
-  if (width > 64 || height > 64) {
-    glitz_glx_context_push_current (surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
-    glitz_texture_size_check (&surface->base.backend->gl,
-                              &surface->base.texture,
-                              context->max_texture_2d_size,
-                              context->max_texture_rect_size);
-    glitz_glx_context_pop_current (surface);
-    if (TEXTURE_INVALID_SIZE (&surface->base.texture) ||
-        (width > context->max_viewport_dims[0]) ||
-        (height > context->max_viewport_dims[1])) {
-      glitz_surface_destroy (&surface->base);
-      return NULL;
-    }
-  }
-    
-  return &surface->base;
-}
-slim_hidden_def(glitz_glx_surface_create_for_window);
-
-static glitz_surface_t *
-_glitz_glx_surface_create_similar (void *abstract_templ,
-                                   glitz_format_t *format,
-                                   int width,
-                                   int height)
-{
-  glitz_glx_surface_t *templ = (glitz_glx_surface_t *) abstract_templ;
-
-  if (!format->read.offscreen)
-    return NULL;
-  
-  return _glitz_glx_surface_create (templ->screen_info, format, width, height);
-}
-
-static void
-_glitz_glx_surface_destroy (void *abstract_surface)
-{
-  glitz_glx_surface_t *surface = (glitz_glx_surface_t *) abstract_surface;
-
-  glitz_surface_fini (&surface->base);
-  
-  if (surface->drawable &&
-      (glXGetCurrentDrawable () == surface->drawable)) {
-    surface->drawable = None;
-    glitz_glx_context_make_current (surface, (GLXContext) 0, 0);
-  }
-
-  if (surface->pbuffer)
-    glitz_glx_pbuffer_destroy (surface->screen_info, surface->pbuffer);
-  
-  free (surface);
-}
-
-static void
-_glitz_glx_surface_swap_buffers (void *abstract_surface)
-{
-  glitz_glx_surface_t *surface = (glitz_glx_surface_t *) abstract_surface;
-
-  if (surface->pbuffer || (!surface->drawable))
-    return;
-
-  glitz_glx_context_push_current (surface, GLITZ_CN_SURFACE_DRAWABLE_CURRENT);
-  
-  glXSwapBuffers (surface->screen_info->display_info->display,
-                  surface->drawable);
-  
-  glitz_glx_context_pop_current (surface);
-}
-
-void
-glitz_glx_surface_backend_init (glitz_surface_backend_t *backend)
-{
-  backend->create_similar = _glitz_glx_surface_create_similar;
-  backend->destroy = _glitz_glx_surface_destroy;
-  backend->push_current = _glitz_glx_surface_push_current;
-  backend->pop_current = _glitz_glx_surface_pop_current;
-  backend->get_texture = _glitz_glx_surface_get_texture;
-  backend->swap_buffers = _glitz_glx_surface_swap_buffers;
-  backend->make_current_read = _glitz_glx_surface_make_current_read;
-}
diff --git a/src/glitz_glxint.h b/src/glitz_glxint.h
deleted file mode 100644
index 5160aa1..0000000
--- a/src/glitz_glxint.h
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
- * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
- *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
- */
-
-#ifndef GLITZ_GLXINT_H_INCLUDED
-#define GLITZ_GLXINT_H_INCLUDED
-
-#include "glitzint.h"
-
-#include "glitz-glx.h"
-
-#include <GL/gl.h>
-#include <GL/glx.h>
-
-#include "glitz_glxext.h"
-
-#define GLITZ_GLX_FEATURE_TEXTURE_RECTANGLE_MASK        (1L <<  0)
-#define GLITZ_GLX_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK (1L <<  1)
-#define GLITZ_GLX_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK  (1L <<  2)
-#define GLITZ_GLX_FEATURE_TEXTURE_BORDER_CLAMP_MASK     (1L <<  3)
-#define GLITZ_GLX_FEATURE_MULTISAMPLE_MASK              (1L <<  4)
-#define GLITZ_GLX_FEATURE_MULTISAMPLE_FILTER_HINT_MASK  (1L <<  5)
-#define GLITZ_GLX_FEATURE_MULTITEXTURE_MASK             (1L <<  6)
-#define GLITZ_GLX_FEATURE_TEXTURE_ENV_COMBINE_MASK      (1L <<  7)
-#define GLITZ_GLX_FEATURE_TEXTURE_ENV_DOT3_MASK         (1L <<  8)
-#define GLITZ_GLX_FEATURE_FRAGMENT_PROGRAM_MASK         (1L <<  9)
-#define GLITZ_GLX_FEATURE_VERTEX_BUFFER_OBJECT_MASK     (1L << 10)
-#define GLITZ_GLX_FEATURE_PIXEL_BUFFER_OBJECT_MASK      (1L << 11)
-#define GLITZ_GLX_FEATURE_BLEND_COLOR_MASK              (1L << 12)
-#define GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK             (1L << 13)
-#define GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK              (1L << 14)
-#define GLITZ_GLX_FEATURE_GLX_MAKE_CURRENT_READ_MASK    (1L << 15)
-#define GLITZ_GLX_FEATURE_GLX_GET_PROC_ADDRESS_MASK     (1L << 16)
-#define GLITZ_GLX_FEATURE_GLX_MULTISAMPLE_MASK          (1L << 17)
-
-typedef struct _glitz_glx_surface glitz_glx_surface_t;
-typedef struct _glitz_glx_screen_info_t glitz_glx_screen_info_t;
-typedef struct _glitz_glx_display_info_t glitz_glx_display_info_t;
-
-typedef struct _glitz_glx_static_proc_address_list_t {
-  glitz_glx_get_proc_address_t get_proc_address;
-  glitz_glx_get_fbconfigs_t get_fbconfigs;
-  glitz_glx_get_fbconfig_attrib_t get_fbconfig_attrib;
-  glitz_glx_get_visual_from_fbconfig_t get_visual_from_fbconfig;
-  glitz_glx_create_pbuffer_t create_pbuffer;
-  glitz_glx_destroy_pbuffer_t destroy_pbuffer;
-  glitz_glx_make_context_current_t make_context_current;
-  glitz_glx_create_new_context_t create_new_context;
-} glitz_glx_static_proc_address_list_t;
-
-typedef struct _glitz_glx_thread_info_t {
-  glitz_glx_display_info_t **displays;
-  int n_displays;
-  char *gl_library;
-  void *dlhand;
-} glitz_glx_thread_info_t;
-
-struct _glitz_glx_display_info_t {
-  glitz_glx_thread_info_t *thread_info;
-  Display *display;
-  glitz_glx_screen_info_t **screens;
-  int n_screens;
-};
-
-typedef struct _glitz_glx_context_info_t {
-  glitz_glx_surface_t *surface;
-  glitz_constraint_t constraint;
-} glitz_glx_context_info_t;
-
-typedef struct _glitz_glx_context_t {
-  GLXContext context;
-  XID id;
-  GLXFBConfig fbconfig;
-  glitz_surface_backend_t backend;
-  glitz_gl_int_t max_viewport_dims[2];
-  glitz_gl_int_t max_texture_2d_size;
-  glitz_gl_int_t max_texture_rect_size;
-} glitz_glx_context_t;
-
-struct _glitz_glx_screen_info_t {
-  glitz_glx_display_info_t *display_info;
-  int screen;
-
-  glitz_format_t *formats;
-  XID *format_ids;
-  int n_formats;
-  
-  glitz_glx_context_t **contexts;
-  int n_contexts;
-  
-  glitz_glx_context_info_t context_stack[GLITZ_CONTEXT_STACK_SIZE];
-  int context_stack_size;
-  
-  glitz_glx_context_t root_context;
-  GLXDrawable root_drawable;
-  Colormap root_colormap;
-
-  unsigned long feature_mask;
-  unsigned long glx_feature_mask;
-  glitz_gl_float_t gl_version;
-  glitz_gl_float_t glx_version;
-
-  glitz_glx_static_proc_address_list_t glx;
-
-  glitz_program_map_t program_map;
-};
-
-struct _glitz_glx_surface {
-  glitz_surface_t base;
-  
-  glitz_glx_screen_info_t *screen_info;
-  glitz_glx_context_t *context;
-  GLXDrawable drawable;
-  GLXDrawable pbuffer;
-};
-
-extern glitz_status_t __internal_linkage
-glitz_glx_query_extensions (glitz_glx_screen_info_t *screen_info);
-
-extern glitz_glx_screen_info_t *__internal_linkage
-glitz_glx_screen_info_get (Display *display,
-                           int screen);
-
-extern glitz_function_pointer_t __internal_linkage
-glitz_glx_get_proc_address (glitz_glx_screen_info_t *screen_info,
-                            const char *name);
-
-extern glitz_glx_context_t *__internal_linkage
-glitz_glx_context_get (glitz_glx_screen_info_t *screen_info,
-                       glitz_format_t *format);
-
-extern void __internal_linkage
-glitz_glx_context_destroy (glitz_glx_screen_info_t *screen_info,
-                           glitz_glx_context_t *context);
-
-extern int __internal_linkage
-glitz_glx_ensure_pbuffer_support (glitz_glx_screen_info_t *screen_info,
-                                  XID fbconfigid);
-
-extern glitz_glx_context_t *__internal_linkage
-glitz_glx_context_get_default (glitz_glx_screen_info_t *screen_info);
-
-extern void __internal_linkage
-glitz_glx_context_make_current (glitz_glx_surface_t *surface,
-                                GLXContext context,
-                                glitz_bool_t flush);
-
-extern glitz_glx_surface_t *__internal_linkage
-glitz_glx_context_push_current (glitz_glx_surface_t *surface,
-                                glitz_constraint_t constraint);
-
-extern glitz_glx_surface_t *__internal_linkage
-glitz_glx_context_pop_current (glitz_glx_surface_t *surface);
-
-extern void __internal_linkage
-glitz_glx_context_proc_address_lookup (glitz_glx_screen_info_t *screen_info,
-                                       glitz_glx_context_t *context);
-
-extern void __internal_linkage
-glitz_glx_query_formats (glitz_glx_screen_info_t *screen_info);
-
-extern GLXPbuffer __internal_linkage
-glitz_glx_pbuffer_create (glitz_glx_screen_info_t *screen_info,
-                          GLXFBConfig fbconfig,
-                          glitz_texture_t *texture);
-
-extern void __internal_linkage
-glitz_glx_pbuffer_destroy (glitz_glx_screen_info_t *screen_info,
-                           GLXPbuffer pbuffer);
-
-extern void __internal_linkage
-glitz_glx_surface_backend_init (glitz_surface_backend_t *backend);
-
-/* Avoid unnecessary PLT entries.  */
-
-slim_hidden_proto(glitz_glx_init)
-slim_hidden_proto(glitz_glx_fini)
-slim_hidden_proto(glitz_glx_find_format)
-slim_hidden_proto(glitz_glx_find_standard_format)
-slim_hidden_proto(glitz_glx_get_visual_info_from_format)
-slim_hidden_proto(glitz_glx_surface_create)
-slim_hidden_proto(glitz_glx_surface_create_for_window)
-
-#endif /* GLITZ_GLXINT_H_INCLUDED */
diff --git a/src/glitz_operator.c b/src/glitz_operator.c
index 6d9975b..223b7ad 100644
--- a/src/glitz_operator.c
+++ b/src/glitz_operator.c
@@ -86,13 +86,5 @@ glitz_set_operator (glitz_gl_proc_address_list_t *gl, glitz_operator_t op) {
     gl->enable (GLITZ_GL_BLEND);
     gl->blend_func (GLITZ_GL_ONE, GLITZ_GL_ONE);
     break;
-  case GLITZ_OPERATOR_SATURATE:
-    gl->enable (GLITZ_GL_BLEND);
-    gl->blend_func (GLITZ_GL_SRC_ALPHA_SATURATE, GLITZ_GL_ONE);
-    break;
-  default:
-    gl->enable (GLITZ_GL_BLEND);
-    gl->blend_func (GLITZ_GL_ZERO, GLITZ_GL_ONE);
-    break;
   }
 }
diff --git a/src/glitz_pixel.c b/src/glitz_pixel.c
index 564ac05..9af952d 100644
--- a/src/glitz_pixel.c
+++ b/src/glitz_pixel.c
@@ -31,13 +31,15 @@
 
 #include <string.h>
 
-typedef struct _glitz_gl_pixel_format glitz_gl_pixel_format_t;
-  
-static struct _glitz_gl_pixel_format {
+#include <stdio.h>
+
+typedef struct _glitz_gl_pixel_format {
   glitz_pixel_format_t pixel;
-  glitz_gl_enum_t format;
-  glitz_gl_enum_t type;
-}  _gl_format_map[] = {
+  glitz_gl_enum_t      format;
+  glitz_gl_enum_t      type;
+} glitz_gl_pixel_format_t;
+  
+static glitz_gl_pixel_format_t _gl_pixel_formats[] = {
   {
     {
       {
@@ -55,8 +57,8 @@ static struct _glitz_gl_pixel_format {
   }, {
     {
       {
-        24,
-        0x00000000,
+        32,
+        0xff000000,
         0x00ff0000,
         0x0000ff00,
         0x000000ff
@@ -64,41 +66,41 @@ static struct _glitz_gl_pixel_format {
       0, 0, 0,
       GLITZ_PIXEL_SCANLINE_ORDER_BOTTOM_UP
     },
+    GLITZ_GL_BGRA,
     
-#if IMAGE_BYTE_ORDER == MSBFirst
-    GLITZ_GL_RGB,
+#if IMAGE_BYTE_ORDER == MSBFirst  
+    GLITZ_GL_UNSIGNED_INT_8_8_8_8_REV
 #else
-    GLITZ_GL_BGR,
+    GLITZ_GL_UNSIGNED_BYTE
 #endif
     
-    GLITZ_GL_UNSIGNED_BYTE
-  }, {
+  }
+};
+
+static glitz_gl_pixel_format_t _gl_packed_pixel_formats[] = {
+  {
     {
       {
-        32,
-        0xff000000,
-        0x00ff0000,
-        0x0000ff00,
-        0x000000ff
+        16,
+        0x00000000,
+        0x0000f800,
+        0x000007e0,
+        0x0000001f
       },
       0, 0, 0,
       GLITZ_PIXEL_SCANLINE_ORDER_BOTTOM_UP
     },
-    GLITZ_GL_BGRA,
+    GLITZ_GL_BGR,
     
 #if IMAGE_BYTE_ORDER == MSBFirst  
-    GLITZ_GL_UNSIGNED_INT_8_8_8_8_REV
+    GLITZ_GL_UNSIGNED_SHORT_5_6_5_REV
 #else
-    GLITZ_GL_UNSIGNED_BYTE
+    GLITZ_GL_UNSIGNED_SHORT_5_6_5
 #endif
     
   }
 };
 
-#define GLITZ_GL_FORMAT_A    0
-#define GLITZ_GL_FORMAT_RGB  1
-#define GLITZ_GL_FORMAT_ARGB 2
-
 typedef struct _glitz_pixel_color {
   uint32_t r, g, b, a;
 } glitz_pixel_color_t;
@@ -286,10 +288,12 @@ static void
 _glitz_pixel_transform (unsigned long transform,
                         glitz_image_t *src,
                         glitz_image_t *dst,
-                        int x_src,
-                        int x_dst,
-                        int width,
-                        int height)
+                        int           x_src,
+                        int           y_src,
+                        int           x_dst,
+                        int           y_dst,
+                        int           width,
+                        int           height)
 {
   int src_stride, dst_stride;
   int x, y, bytes_per_pixel = 0;
@@ -352,11 +356,11 @@ _glitz_pixel_transform (unsigned long transform,
 
   for (y = 0; y < height; y++) {
     if (src->format->scanline_order != dst->format->scanline_order)
-      src_op.line = &src->data[(src->height - y - 1) * src_stride];
+      src_op.line = &src->data[(src->height - (y + y_src) - 1) * src_stride];
     else
-      src_op.line = &src->data[y * src_stride];
+      src_op.line = &src->data[(y + y_src) * src_stride];
 
-    dst_op.line = &dst->data[y * dst_stride];
+    dst_op.line = &dst->data[(y + y_dst) * dst_stride];
     
     if (transform & GLITZ_TRANSFORM_PIXELS_MASK) {
       for (x = 0; x < width; x++) {
@@ -371,7 +375,7 @@ _glitz_pixel_transform (unsigned long transform,
          it will never be used for bitmaps */
       if (bytes_per_pixel == 0)
         bytes_per_pixel = src->format->masks.bpp / 8;
-      
+
       memcpy (&dst_op.line[x_dst * bytes_per_pixel],
               &src_op.line[x_src * bytes_per_pixel],
               width * bytes_per_pixel);
@@ -379,49 +383,174 @@ _glitz_pixel_transform (unsigned long transform,
   }
 }
 
+static glitz_bool_t
+_glitz_format_match (glitz_pixel_masks_t  *masks1,
+                     glitz_pixel_masks_t  *masks2,
+                     glitz_color_format_t *internal_color)
+{
+  if (masks1->bpp != masks2->bpp)
+    return 0;
+    
+  if (internal_color->red_size)
+    if (masks1->red_mask != masks2->red_mask)
+      return 0;
+
+  if (internal_color->green_size)
+    if (masks1->green_mask != masks2->green_mask)
+      return 0;
+
+  if (internal_color->blue_size)
+    if (masks1->blue_mask != masks2->blue_mask)
+      return 0;
+  
+  if (internal_color->alpha_size)
+    if (masks1->alpha_mask != masks2->alpha_mask)
+      return 0;
+  
+  return 1;
+}
+
 static glitz_gl_pixel_format_t *
-_glitz_find_gl_pixel_format (glitz_pixel_format_t *format)
+_glitz_find_gl_pixel_format (glitz_pixel_format_t *format,
+                             glitz_color_format_t *internal_color,
+                             unsigned long        feature_mask)
 {
   int i, n_formats;
 
-  n_formats = sizeof (_gl_format_map) / sizeof (glitz_gl_pixel_format_t);
+  n_formats = sizeof (_gl_pixel_formats) / sizeof (glitz_gl_pixel_format_t);
   for (i = 0; i < n_formats; i++) {
-    if (memcmp (&_gl_format_map[i].pixel.masks, &format->masks,
-                sizeof (glitz_pixel_masks_t)) == 0)
-      return &_gl_format_map[i];
+    if (_glitz_format_match (&_gl_pixel_formats[i].pixel.masks, &format->masks,
+                             internal_color))
+      return &_gl_pixel_formats[i];
+  }
+  
+  if (feature_mask & GLITZ_FEATURE_PACKED_PIXELS_MASK) {
+    n_formats = sizeof (_gl_packed_pixel_formats) /
+      sizeof (glitz_gl_pixel_format_t);
+    
+    for (i = 0; i < n_formats; i++) {
+      if (_glitz_format_match (&_gl_packed_pixel_formats[i].pixel.masks,
+                               &format->masks,
+                               internal_color))
+        return &_gl_packed_pixel_formats[i];
+    }
   }
   
   return NULL;
 }
 
+static int
+_component_size (unsigned long mask)
+{
+  unsigned long y;
+  
+  /* HACKMEM 169 */
+  y = (mask >> 1) & 033333333333;
+  y = mask - y - ((y >> 1) & 033333333333);
+  return (((y + (y >> 3)) & 030707070707) % 077);
+}
+
+static glitz_bool_t
+_glitz_format_diff (glitz_pixel_masks_t  *masks,
+                    glitz_color_format_t *pixel_color,
+                    glitz_color_format_t *internal_color,
+                    int                  *diff)
+{
+  int size;
+  
+  *diff = 0;
+
+  size = _component_size (masks->red_mask);
+  if (size < pixel_color->red_size && size < internal_color->red_size)
+    return 0;
+  
+  *diff += abs (size - internal_color->red_size);
+
+  size = _component_size (masks->green_mask);
+  if (size < pixel_color->green_size && size < internal_color->green_size)
+    return 0;
+  
+  *diff += abs (size - internal_color->green_size);
+
+  size = _component_size (masks->blue_mask);
+  if (size < pixel_color->blue_size && size < internal_color->blue_size)
+    return 0;
+  
+  *diff += abs (size - internal_color->blue_size);
+
+  size = _component_size (masks->alpha_mask);
+  if (size < pixel_color->alpha_size && size < internal_color->alpha_size)
+    return 0;
+  
+  *diff += abs (size - internal_color->alpha_size);
+  
+  return 1;
+}
+
 static glitz_gl_pixel_format_t *
-_glitz_best_gl_pixel_format (glitz_format_t *format)
+_glitz_find_best_gl_pixel_format (glitz_pixel_format_t *format,
+                                  glitz_color_format_t *internal_color,
+                                  unsigned long        feature_mask)
 {
-  if (format->red_size) {
-    if (format->alpha_size)
-      return &_gl_format_map[GLITZ_GL_FORMAT_ARGB];
-    else
-      return &_gl_format_map[GLITZ_GL_FORMAT_RGB];
-  } else
-    return &_gl_format_map[GLITZ_GL_FORMAT_A];
+  glitz_gl_pixel_format_t *best = NULL;
+  glitz_color_format_t color;
+  int i, n_formats, diff, best_diff = MAXSHORT;
+
+  color.red_size = _component_size (format->masks.red_mask);
+  color.green_size = _component_size (format->masks.green_mask);
+  color.blue_size = _component_size (format->masks.blue_mask);
+  color.alpha_size = _component_size (format->masks.alpha_mask);
+
+  n_formats = sizeof (_gl_pixel_formats) / sizeof (glitz_gl_pixel_format_t);
+  for (i = 0; best_diff > 0 && i < n_formats; i++) {
+    if (_glitz_format_diff (&_gl_pixel_formats[i].pixel.masks,
+                            &color,
+                            internal_color,
+                            &diff)) {
+      if (diff < best_diff) {
+        best = &_gl_pixel_formats[i];
+        best_diff = diff;
+      }
+    }
+  }
+  
+  if (feature_mask & GLITZ_FEATURE_PACKED_PIXELS_MASK) {
+    n_formats = sizeof (_gl_packed_pixel_formats) /
+      sizeof (glitz_gl_pixel_format_t);
+    
+    for (i = 0; best_diff > 0 && i < n_formats; i++) {
+      if (_glitz_format_diff (&_gl_packed_pixel_formats[i].pixel.masks,
+                              &color,
+                              internal_color,
+                              &diff)) {
+        if (diff < best_diff) {
+          best = &_gl_packed_pixel_formats[i];
+          best_diff = diff;
+        }
+      }
+    }
+  }
+
+  return best;
 }
 
 void
-glitz_set_pixels (glitz_surface_t *dst,
-                  int x_dst,
-                  int y_dst,
-                  int width,
-                  int height,
+glitz_set_pixels (glitz_surface_t      *dst,
+                  int                  x_dst,
+                  int                  y_dst,
+                  int                  width,
+                  int                  height,
                   glitz_pixel_format_t *format,
-                  glitz_buffer_t *buffer)
+                  glitz_buffer_t       *buffer)
 {
-  glitz_gl_proc_address_list_t *gl;
-  glitz_bool_t to_drawable;
   glitz_texture_t *texture;
   char *pixels, *data = NULL;
   glitz_gl_pixel_format_t *gl_format = NULL;
   unsigned long transform = 0;
   int xoffset, bytes_per_line, bpp;
+  glitz_box_t box;
+
+  GLITZ_GL_SURFACE (dst);
 
   if (x_dst < 0 || x_dst > (dst->width - width) ||
       y_dst < 0 || y_dst > (dst->height - height)) {
@@ -429,28 +558,24 @@ glitz_set_pixels (glitz_surface_t *dst,
     return;
   }
 
-  gl = &dst->backend->gl;
-
-  if (format->scanline_order == GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN)
-    transform |= GLITZ_TRANSFORM_SCANLINE_ORDER_MASK;
-
   /* find direct format */
-  gl_format = _glitz_find_gl_pixel_format (format);
+  gl_format =
+    _glitz_find_gl_pixel_format (format,
+                                 &dst->format->color,
+                                 dst->drawable->backend->feature_mask);
   if (gl_format == NULL) {
     transform |= GLITZ_TRANSFORM_PIXELS_MASK;
-    gl_format = _glitz_best_gl_pixel_format (dst->format);
+    gl_format =
+      _glitz_find_best_gl_pixel_format (format,
+                                        &dst->format->color,
+                                        dst->drawable->backend->feature_mask);
   }
 
-  if (SURFACE_DRAWABLE (dst))
-    to_drawable = 1;
-  else
-    to_drawable = 0;
-
-  if (to_drawable) {
-    if (!glitz_surface_push_current (dst, GLITZ_CN_SURFACE_DRAWABLE_CURRENT))
-      to_drawable = 0;
-  } else
-    glitz_surface_push_current (dst, GLITZ_CN_ANY_CONTEXT_CURRENT);
+  /* should not happen */
+  if (gl_format == NULL)
+    return;
+  
+  glitz_surface_push_current (dst, GLITZ_ANY_CONTEXT_CURRENT);
 
   texture = glitz_surface_get_texture (dst, 1);
   if (!texture) {
@@ -458,6 +583,11 @@ glitz_set_pixels (glitz_surface_t *dst,
     return;
   }
 
+  if (height > 1) {
+    if (format->scanline_order == GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN)
+      transform |= GLITZ_TRANSFORM_SCANLINE_ORDER_MASK;
+  }
+
   glitz_texture_bind (gl, texture);
   
   if (transform) {
@@ -488,8 +618,8 @@ glitz_set_pixels (glitz_surface_t *dst,
     _glitz_pixel_transform (transform,
                             &src_image,
                             &dst_image,
-                            format->xoffset,
-                            0,
+                            format->xoffset, 0,
+                            0, 0,
                             width, height);
 
     glitz_buffer_unmap (buffer);
@@ -534,42 +664,17 @@ glitz_set_pixels (glitz_surface_t *dst,
 
   if (transform == 0)
     glitz_buffer_unbind (buffer);
-
-  if (to_drawable) {
-    glitz_bounding_box_t box;
-
-    box.x1 = x_dst;
-    box.y1 = y_dst;
-    box.x2 = box.x1 + width;
-    box.y2 = box.y1 + height;
-    
-    glitz_texture_set_tex_gen (gl, texture, 0, 0, 0); 
-
-    gl->tex_env_f (GLITZ_GL_TEXTURE_ENV, GLITZ_GL_TEXTURE_ENV_MODE,
-                   GLITZ_GL_REPLACE);
-    gl->color_4us (0x0, 0x0, 0x0, 0xffff);
-    
-    glitz_texture_ensure_wrap (gl, texture, GLITZ_GL_CLAMP_TO_EDGE);
-    glitz_texture_ensure_filter (gl, texture, GLITZ_GL_NEAREST);
-
-    glitz_set_operator (gl, GLITZ_OPERATOR_SRC);
-
-    gl->scissor (box.x1,
-                 dst->height - box.y2,
-                 width, height);
-
-    glitz_geometry_enable_default (gl, dst, &box);
-
-    gl->draw_arrays (GLITZ_GL_QUADS, 0, 4);
-
-    if (x_dst == 0 && y_dst == 0 &&
-        width == dst->width && height == dst->height)
-      dst->flags &= ~GLITZ_SURFACE_FLAG_DIRTY_MASK;
-  }
   
   glitz_texture_unbind (gl, texture);
 
-  dst->flags |= GLITZ_SURFACE_FLAG_SOLID_DIRTY_MASK;
+  box.x1 = x_dst;
+  box.y1 = y_dst;
+  box.x2 = box.x1 + width;
+  box.y2 = box.y1 + height;
+
+  glitz_surface_damage (dst, &box,
+                        GLITZ_DAMAGE_DRAWABLE_MASK |
+                        GLITZ_DAMAGE_SOLID_MASK);
   
   glitz_surface_pop_current (dst);
   
@@ -578,15 +683,14 @@ glitz_set_pixels (glitz_surface_t *dst,
 }
 
 void
-glitz_get_pixels (glitz_surface_t *src,
-                  int x_src,
-                  int y_src,
-                  int width,
-                  int height,
+glitz_get_pixels (glitz_surface_t      *src,
+                  int                  x_src,
+                  int                  y_src,
+                  int                  width,
+                  int                  height,
                   glitz_pixel_format_t *format,
-                  glitz_buffer_t *buffer)
+                  glitz_buffer_t       *buffer)
 {
-  glitz_gl_proc_address_list_t *gl;
   glitz_bool_t from_drawable;
   glitz_texture_t *texture = NULL;
   char *pixels, *data = NULL;
@@ -594,6 +698,9 @@ glitz_get_pixels (glitz_surface_t *src,
   unsigned long transform = 0;
   int src_x = 0, src_y = 0, src_w = width, src_h = height;
   int xoffset, bytes_per_line, bpp;
+  glitz_color_format_t *color;
+
+  GLITZ_GL_SURFACE (src);
   
   if (x_src < 0 || x_src > (src->width - width) ||
       y_src < 0 || y_src > (src->height - height)) {
@@ -601,12 +708,12 @@ glitz_get_pixels (glitz_surface_t *src,
     return;
   }
 
-  gl = &src->backend->gl;
-
-  if (glitz_surface_push_current (src, GLITZ_CN_SURFACE_DRAWABLE_CURRENT)) {
+  if (glitz_surface_push_current (src, GLITZ_DRAWABLE_CURRENT)) {
     from_drawable = 1;
+    color = &src->attached->format->color;
   } else {
     from_drawable = 0;
+    color = &src->format->color;
     
     texture = glitz_surface_get_texture (src, 0);
     if (!texture) {
@@ -614,17 +721,31 @@ glitz_get_pixels (glitz_surface_t *src,
       return;
     }
 
-    transform |= GLITZ_TRANSFORM_COPY_BOX_MASK;
+    if (texture->width > width || texture->height > height)
+      transform |= GLITZ_TRANSFORM_COPY_BOX_MASK;
   }
   
-  if (format->scanline_order == GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN)
-    transform |= GLITZ_TRANSFORM_SCANLINE_ORDER_MASK;
-  
+  if (transform || height > 1) {
+    if (format->scanline_order == GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN)
+      transform |= GLITZ_TRANSFORM_SCANLINE_ORDER_MASK;
+  }
+
   /* find direct format */
-  gl_format = _glitz_find_gl_pixel_format (format);
+  gl_format =
+    _glitz_find_gl_pixel_format (format, color,
+                                 src->drawable->backend->feature_mask);
   if (gl_format == NULL) {
     transform |= GLITZ_TRANSFORM_PIXELS_MASK;
-    gl_format = _glitz_best_gl_pixel_format (src->format);
+    
+    gl_format =
+      _glitz_find_best_gl_pixel_format (format, color,
+                                        src->drawable->backend->feature_mask);
+  }
+
+  /* should not happen */
+  if (gl_format == NULL) {
+    glitz_surface_pop_current (src);
+    return;
   }
   
   if (transform) {
@@ -675,21 +796,18 @@ glitz_get_pixels (glitz_surface_t *src,
     gl->pixel_store_i (GLITZ_GL_PACK_ROW_LENGTH, 0);
   }
 
-  if (from_drawable) {
-    if (SURFACE_OFFSCREEN (src)) {
-       x_src += src->texture.box.x1;
-       y_src += src->texture.box.y1;
-    }
-
-    if (src->format->doublebuffer)
-      gl->read_buffer (src->read_buffer);
+  if (from_drawable) {    
+    gl->read_buffer (src->buffer);
+    
+    gl->disable (GLITZ_GL_SCISSOR_TEST);
 
-    gl->scissor (0, 0, src->width, src->height);
-      
-    gl->read_pixels (x_src, src->height - y_src - height,
+    gl->read_pixels (x_src + src->x,
+                     src->attached->height - (y_src + src->y) - height,
                      width, height,
                      gl_format->format, gl_format->type,
                      pixels);
+    
+    gl->enable (GLITZ_GL_SCISSOR_TEST);
   } else {
     glitz_texture_bind (gl, texture);
     gl->get_tex_image (texture->target, 0,
@@ -700,29 +818,22 @@ glitz_get_pixels (glitz_surface_t *src,
 
   if (transform) {
     glitz_image_t src_image, dst_image;
-    int stride;
 
-    src_image.data = data + src_y * bytes_per_line;
+    src_image.data = data;
     src_image.format = &gl_format->pixel;
     src_image.width = src_w;
     src_image.height = src_h;
 
-    if (format->bytes_per_line)
-      stride = format->bytes_per_line;
-    else
-      stride = (((width * format->masks.bpp) / 8) + 3) & -4;
-    
     dst_image.data = glitz_buffer_map (buffer, GLITZ_BUFFER_ACCESS_WRITE_ONLY);
-    dst_image.data += format->skip_lines * stride;
     dst_image.format = format;
     dst_image.width = width;
     dst_image.height = height;
-    
+
     _glitz_pixel_transform (transform,
                             &src_image,
                             &dst_image,
-                            src_x,
-                            format->xoffset,
+                            src_x, src_y,
+                            format->xoffset, format->skip_lines,
                             width, height);
 
     glitz_buffer_unmap (buffer);
diff --git a/src/glitz_program.c b/src/glitz_program.c
index 6930ab2..01f6bae 100644
--- a/src/glitz_program.c
+++ b/src/glitz_program.c
@@ -346,9 +346,9 @@ _string_array_to_char_array (char *dst, const char *src[])
 #define GRADIENT_STOP_SIZE 256
 
 static glitz_gl_uint_t
-_glitz_create_fragment_program (glitz_composite_op_t *op,
-                                int fp_type,
-                                int id,
+_glitz_create_fragment_program (glitz_composite_op_t         *op,
+                                int                          fp_type,
+                                int                          id,
                                 const glitz_program_expand_t *expand)
 {
   char buffer[1024], *program = NULL, *tex, *p = NULL;
@@ -481,7 +481,7 @@ glitz_program_map_init (glitz_program_map_t *map)
 
 void
 glitz_program_map_fini (glitz_gl_proc_address_list_t *gl,
-                        glitz_program_map_t *map)
+                        glitz_program_map_t          *map)
 {
   glitz_gl_uint_t program;
   int i, j, k, x, y;
@@ -518,15 +518,16 @@ glitz_program_map_fini (glitz_gl_proc_address_list_t *gl,
 
 glitz_gl_uint_t
 glitz_get_fragment_program (glitz_composite_op_t *op,
-                            int fp_type,
-                            int id)
+                            int                  fp_type,
+                            int                  id)
 {
+  glitz_program_map_t *map;
   glitz_program_t *program;
   int t0 = TEXTURE_INDEX (op->src);
   int t1 = TEXTURE_INDEX (op->mask);
 
-  program =
-    &op->dst->backend->program_map->filters[op->type][fp_type].fp[t0][t1];
+  map = op->dst->drawable->backend->program_map;
+  program = &map->filters[op->type][fp_type].fp[t0][t1];
   
   if (program->size < id) {
     int old_size;
@@ -544,7 +545,7 @@ glitz_get_fragment_program (glitz_composite_op_t *op,
   }
   
   if (program->name[id - 1] == 0) {
-    glitz_surface_push_current (op->dst, GLITZ_CN_SURFACE_CONTEXT_CURRENT);
+    glitz_surface_push_current (op->dst, GLITZ_CONTEXT_CURRENT);
     
     program->name[id - 1] =
       _glitz_create_fragment_program (op, fp_type, id,
diff --git a/src/glitz_rect.c b/src/glitz_rect.c
index 22a8aa3..233fd4c 100644
--- a/src/glitz_rect.c
+++ b/src/glitz_rect.c
@@ -37,8 +37,8 @@
 
 static void
 glitz_rectangle_bounds (const glitz_rectangle_t *rects,
-                        int n_rects,
-                        glitz_bounding_box_t *box)
+                        int                     n_rects,
+                        glitz_box_t             *box)
 {
   box->x1 = MAXSHORT;
   box->x2 = MINSHORT;
@@ -58,31 +58,34 @@ glitz_rectangle_bounds (const glitz_rectangle_t *rects,
 }
 
 void
-glitz_set_rectangles (glitz_surface_t *dst,
-                      const glitz_color_t *color,
+glitz_set_rectangles (glitz_surface_t         *dst,
+                      const glitz_color_t     *color,
                       const glitz_rectangle_t *rects,
-                      int n_rects)
+                      int                     n_rects)
 {
-  glitz_bounding_box_t bounds;
-  glitz_gl_proc_address_list_t *gl = &dst->backend->gl;
+  glitz_box_t bounds;
+
+  GLITZ_GL_SURFACE (dst);
 
   glitz_rectangle_bounds (rects, n_rects, &bounds);
   if (bounds.x1 > dst->width || bounds.y1 > dst->height ||
       bounds.x2 < 0 || bounds.y2 < 0)
     return;
 
-  if (SURFACE_SOLID (dst) && SURFACE_OFFSCREEN (dst) &&
+  if (SURFACE_SOLID (dst) &&
       (bounds.x2 - bounds.x1) > 0 && (bounds.y2 - bounds.y1) > 0) {
-    STORE_16 (dst->solid.red, dst->format->red_size, color->red);
-    STORE_16 (dst->solid.green, dst->format->green_size, color->green);
-    STORE_16 (dst->solid.blue, dst->format->blue_size, color->blue);
-    STORE_16 (dst->solid.alpha, dst->format->alpha_size, color->alpha);
-    
-    dst->flags |= GLITZ_SURFACE_FLAG_DRAWABLE_DIRTY_MASK;
+    STORE_16 (dst->solid.red, dst->format->color.red_size, color->red);
+    STORE_16 (dst->solid.green, dst->format->color.green_size, color->green);
+    STORE_16 (dst->solid.blue, dst->format->color.blue_size, color->blue);
+    STORE_16 (dst->solid.alpha, dst->format->color.alpha_size, color->alpha);
+
+    glitz_surface_damage (dst, &bounds,
+                          GLITZ_DAMAGE_TEXTURE_MASK |
+                          GLITZ_DAMAGE_DRAWABLE_MASK);
     return;
   }
 
-  if (glitz_surface_push_current (dst, GLITZ_CN_SURFACE_DRAWABLE_CURRENT)) {
+  if (glitz_surface_push_current (dst, GLITZ_DRAWABLE_CURRENT)) {
     gl->clear_color (color->red / (glitz_gl_clampf_t) 0xffff,
                      color->green / (glitz_gl_clampf_t) 0xffff,
                      color->blue / (glitz_gl_clampf_t) 0xffff,
@@ -90,12 +93,14 @@ glitz_set_rectangles (glitz_surface_t *dst,
 
     for (; n_rects; n_rects--, rects++) {
       gl->scissor (rects->x,
-                   dst->height - rects->y - rects->height,
+                   dst->attached->height - dst->y - rects->y - rects->height,
                    rects->width,
                    rects->height);
       gl->clear (GLITZ_GL_COLOR_BUFFER_BIT);
     }
-    glitz_surface_dirty (dst, &bounds);
+    glitz_surface_damage (dst, &bounds,
+                          GLITZ_DAMAGE_TEXTURE_MASK |
+                          GLITZ_DAMAGE_SOLID_MASK);
   } else {
     static glitz_pixel_format_t pf = {
       {
@@ -154,12 +159,12 @@ glitz_set_rectangles (glitz_surface_t *dst,
 slim_hidden_def(glitz_set_rectangles);
 
 void
-glitz_set_rectangle (glitz_surface_t *dst,
+glitz_set_rectangle (glitz_surface_t     *dst,
                      const glitz_color_t *color,
-                     int x,
-                     int y,
-                     unsigned int width,
-                     unsigned int height)
+                     int                 x,
+                     int                 y,
+                     unsigned int        width,
+                     unsigned int        height)
 {
   glitz_rectangle_t rect;
 
diff --git a/src/glitz_region.c b/src/glitz_region.c
new file mode 100644
index 0000000..253ad31
--- /dev/null
+++ b/src/glitz_region.c
@@ -0,0 +1,166 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitzint.h"
+
+#define REGION_ALLOC_CHUNK 16
+
+#define BOX_SUBSUMS_BOX(b1, b2) \
+  ((b2)->x1 >= (b1)->x1 && \
+   (b2)->x2 <= (b1)->x2 && \
+   (b2)->y1 >= (b1)->y1 && \
+   (b2)->y2 <= (b1)->y2)
+
+#define BOX_INTERSECTS_BOX(b1, b2) \
+  ((b1)->x1 < (b2)->x2 && \
+   (b1)->x2 > (b2)->x1 && \
+   (b1)->y1 < (b2)->y2 && \
+   (b1)->y2 > (b2)->y1)
+
+#define BOX_CLOSE_TO_BOX(b1, b2) \
+  ((b1)->x1 < ((b2)->x2 + 1) && \
+   (b1)->x2 > ((b2)->x1 - 1) && \
+   (b1)->y1 < ((b2)->y2 + 1) && \
+   (b1)->y2 > ((b2)->y1 - 1))
+
+#define BOX_NEXT_TO_BOX(b1, b2) \
+  ((((b1)->x1 == (b2)->x2 || \
+	(b1)->x2 == (b2)->x1) && \
+    (b1)->y1 == (b2)->y1 && \
+    (b1)->y2 == (b2)->y2) || \
+   (((b1)->y1 == (b2)->y2 || \
+     (b1)->y2 == (b2)->y1) && \
+    (b1)->x1 == (b2)->x1 && \
+    (b1)->x2 == (b2)->x2))
+
+#define MERGE_BOXES(d, b1, b2) \
+  { \
+    (d)->x1 = MIN ((b1)->x1, (b2)->x1); \
+    (d)->y1 = MIN ((b1)->y1, (b2)->y1); \
+    (d)->x2 = MAX ((b1)->x2, (b2)->x2); \
+    (d)->y2 = MAX ((b1)->y2, (b2)->y2); \
+  }
+
+/*
+ * No real union, boxes that intersect are just joined into bigger boxes.
+ * This is OK for our needs and it keeps the number of boxes down to a
+ * minimum and makes it faster.
+ */
+glitz_status_t
+glitz_region_union (glitz_region_t *region,
+                    glitz_box_t    *ubox)
+{ 
+  if (region->n_box == 0) {
+    region->extents = *ubox;
+    region->box = &region->extents;
+    region->n_box = 1;
+
+    return GLITZ_STATUS_SUCCESS;
+  }
+
+  if (BOX_CLOSE_TO_BOX (ubox, &region->extents)) {
+    glitz_box_t *box, *new_box, *dst_box;
+    int         n_box;
+
+    box = region->box;
+    n_box = region->n_box;
+
+    while (n_box--) {
+      if (BOX_SUBSUMS_BOX (box, ubox))
+        return GLITZ_STATUS_SUCCESS;
+        
+      box++;
+    }
+      
+    box = region->box;
+    n_box = region->n_box;
+
+    new_box = ubox;
+    dst_box = NULL;
+    while (n_box--) {
+
+      if (BOX_INTERSECTS_BOX (box, new_box) ||
+          BOX_NEXT_TO_BOX (box, new_box)) {
+	    
+        if (dst_box) {
+          /*
+           * Remove box from region
+           */
+          region->n_box--;
+          if (region->n_box == 1) {
+            MERGE_BOXES (&region->extents, box, new_box);
+            region->box = &region->extents;
+            
+            return GLITZ_STATUS_SUCCESS;
+          } else {
+            MERGE_BOXES (dst_box, box, new_box);
+            if (n_box)
+              memmove (box, box + 1, n_box * sizeof (glitz_box_t));
+          }
+          continue;
+        } else {
+          dst_box = box;
+          MERGE_BOXES (dst_box, box, new_box);
+          new_box = dst_box;
+        }
+      }
+      box++;
+    }
+    
+    if (dst_box) {
+      if (region->n_box > 1)
+        MERGE_BOXES (&region->extents, &region->extents, ubox);
+      
+      return GLITZ_STATUS_SUCCESS;
+    }
+  }
+
+  /*
+   * Add box to region
+   */
+  if (region->size < (region->n_box + 1)) {
+    region->size += REGION_ALLOC_CHUNK;
+    region->data = (void *) realloc (region->data,
+				     sizeof (glitz_box_t) * region->size);
+    if (!region->data)
+      return GLITZ_STATUS_NO_MEMORY;
+  }
+
+  region->box = (glitz_box_t *) region->data;
+  
+  region->box[region->n_box] = *ubox;
+  if (region->n_box == 1)
+    region->box[0] = region->extents;
+
+  region->n_box++;
+
+  MERGE_BOXES (&region->extents, &region->extents, ubox);
+  
+  return GLITZ_STATUS_SUCCESS;
+}
diff --git a/src/glitz_surface.c b/src/glitz_surface.c
index f765b83..74c73af 100644
--- a/src/glitz_surface.c
+++ b/src/glitz_surface.c
@@ -32,94 +32,92 @@
 #include <stdlib.h>
 #include <string.h>
 
-void
-glitz_surface_init (glitz_surface_t *surface,
-                    glitz_surface_backend_t *backend,
-                    glitz_format_t *format,
-                    int width,
-                    int height)
+glitz_surface_t *
+glitz_surface_create (glitz_drawable_t *drawable,
+                      glitz_format_t   *format,
+                      unsigned int     width,
+                      unsigned int     height)
 {
-  surface->backend = backend;
+  glitz_surface_t *surface;
+  
+  if (width == 0 || height == 0)
+    return NULL;
 
-  surface->ref_count = 1;
+  surface = (glitz_surface_t *) calloc (1, sizeof (glitz_surface_t));
+  if (surface == NULL)
+    return NULL;
 
-  surface->filter = GLITZ_FILTER_NEAREST;
+  surface->drawable = drawable;
+  glitz_drawable_reference (drawable);
   
+  surface->ref_count = 1;
+  surface->filter = GLITZ_FILTER_NEAREST;  
   surface->format = format;
-  surface->width = width;
-  surface->height = height;
-  surface->update_mask = GLITZ_UPDATE_ALL_MASK;
+  surface->width = (int) width;
+  surface->height = (int) height;
+  surface->buffer = GLITZ_GL_FRONT;
 
-  if (format->doublebuffer)
-    surface->draw_buffer = surface->read_buffer = GLITZ_GL_BACK;
-  else
-    surface->draw_buffer = surface->read_buffer = GLITZ_GL_FRONT;
+  REGION_INIT (&surface->texture_damage, NULL_BOX);
+  REGION_INIT (&surface->drawable_damage, NULL_BOX);
 
   if (width == 1 && height == 1) {
     surface->flags |= GLITZ_SURFACE_FLAG_SOLID_MASK;
-    surface->solid.red = surface->solid.green = surface->solid.blue = 0x0;
     surface->solid.alpha = 0xffff;
   }
-
-  glitz_texture_init (&surface->texture,
-                      width, height,
-                      glitz_format_get_best_texture_format (backend->formats,
-                                                            backend->n_formats,
-                                                            format),
-                      backend->feature_mask);
+  
+  glitz_texture_init (&surface->texture, width, height,
+                      drawable->backend->texture_formats[format->id],
+                      drawable->backend->feature_mask);
+  
+  if (width > 64 || height > 64) {
+    glitz_surface_push_current (surface, GLITZ_CONTEXT_CURRENT);
+    glitz_texture_size_check (&drawable->backend->gl, &surface->texture,
+                              drawable->backend->max_texture_2d_size,
+                              drawable->backend->max_texture_rect_size);
+    glitz_surface_pop_current (surface);
+    if (TEXTURE_INVALID_SIZE (&surface->texture)) {
+      glitz_surface_destroy (surface);
+      return NULL;
+    }
+  }
+  
+  return surface;
 }
 
 void
-glitz_surface_fini (glitz_surface_t *surface)
+glitz_surface_destroy (glitz_surface_t *surface)
 {
-  if (surface->geometry.buffer)
-    glitz_buffer_destroy (surface->geometry.buffer);
-   
+  if (!surface)
+    return;
+
+  surface->ref_count--;
+  if (surface->ref_count)
+    return;
+
   if (surface->texture.name) {
-    glitz_surface_push_current (surface, GLITZ_CN_ANY_CONTEXT_CURRENT);
-    glitz_texture_fini (&surface->backend->gl, &surface->texture);
+    glitz_surface_push_current (surface, GLITZ_ANY_CONTEXT_CURRENT);
+    glitz_texture_fini (&surface->drawable->backend->gl, &surface->texture);
     glitz_surface_pop_current (surface);
   }
+
+  REGION_UNINIT (&surface->texture_damage);
+  REGION_UNINIT (&surface->drawable_damage);
+  
+  if (surface->geometry.buffer)
+    glitz_buffer_destroy (surface->geometry.buffer);
   
   if (surface->transform)
     free (surface->transform);
   
   if (surface->filter_params)
     glitz_filter_params_destroy (surface->filter_params);
-}
-
-glitz_format_t *
-glitz_surface_find_similar_standard_format (glitz_surface_t *surface,
-                                            glitz_format_name_t format_name)
-{
-  return
-    glitz_format_find_standard (surface->backend->formats,
-                                surface->backend->n_formats,
-                                format_name);
-}
-slim_hidden_def(glitz_surface_find_similar_standard_format);
-
-glitz_format_t *
-glitz_surface_find_similar_format (glitz_surface_t *surface,
-                                   unsigned long mask,
-                                   const glitz_format_t *templ,
-                                   int count)
-{
-  return glitz_format_find (surface->backend->formats,
-                            surface->backend->n_formats,
-                            mask, templ, count);
-}
 
-glitz_surface_t *
-glitz_surface_create_similar (glitz_surface_t *templ,
-                              glitz_format_t *format,
-                              int width,
-                              int height)
-{
-  if (width < 1 || height < 1)
-    return NULL;
+  if (surface->attached)
+    glitz_drawable_destroy (surface->attached);
   
-  return templ->backend->create_similar (templ, format, width, height);
+  glitz_drawable_destroy (surface->drawable);
+
+  free (surface);
 }
 
 void
@@ -131,70 +129,161 @@ glitz_surface_reference (glitz_surface_t *surface)
   surface->ref_count++;
 }
 
-void
-glitz_surface_destroy (glitz_surface_t *surface)
+static void
+_glitz_surface_sync_texture (glitz_surface_t *surface)
 {
-  if (!surface)
-    return;
+  if (REGION_NOTEMPTY (&surface->texture_damage)) {
+    glitz_box_t *box;
+    int         n_box;
 
-  surface->ref_count--;
-  if (surface->ref_count)
-    return;
+    GLITZ_GL_SURFACE (surface);
+
+    if (!(TEXTURE_ALLOCATED (&surface->texture)))
+      glitz_texture_allocate (gl, &surface->texture);
+
+    if (SURFACE_SOLID (surface) && (!SURFACE_SOLID_DAMAGE (surface))) {
+      glitz_gl_float_t color[4];
+
+      if (TEXTURE_ALLOCATED (&surface->texture)) {
+        color[0] = surface->solid.red / 65535.0f;
+        color[1] = surface->solid.green / 65535.0f;
+        color[2] = surface->solid.blue / 65535.0f;
+        color[3] = surface->solid.alpha / 65535.0f;
+    
+        glitz_texture_bind (gl, &surface->texture);
+        gl->tex_sub_image_2d (surface->texture.target, 0,
+                              surface->texture.box.x1, surface->texture.box.y1,
+                              1, 1, GLITZ_GL_RGBA, GLITZ_GL_FLOAT, color);
+        glitz_texture_unbind (gl, &surface->texture);
+      }
+      REGION_EMPTY (&surface->texture_damage);
+      return;
+    }
+
+    glitz_surface_push_current (surface, GLITZ_DRAWABLE_CURRENT);
+
+    gl->read_buffer (surface->buffer);
+
+    gl->disable (GLITZ_GL_SCISSOR_TEST);
+
+    glitz_texture_bind (gl, &surface->texture);
+
+    box = REGION_RECTS (&surface->texture_damage);
+    n_box = REGION_NUM_RECTS (&surface->texture_damage);
   
-  surface->backend->destroy (surface);
+    while (n_box--) {
+      glitz_texture_copy_drawable (gl,
+                                   &surface->texture,
+                                   surface->attached,
+                                   box->x1 + surface->x,
+                                   box->y1 + surface->y,
+                                   box->x2 - box->x1,
+                                   box->y2 - box->y1,
+                                   box->x1,
+                                   box->y1);
+      
+      box++;
+    }
+
+    REGION_EMPTY (&surface->texture_damage);
+
+    glitz_texture_unbind (gl, &surface->texture);
+
+    gl->enable (GLITZ_GL_SCISSOR_TEST);
+
+    glitz_surface_pop_current (surface);
+  }
 }
 
 static void
-_glitz_surface_solid_store (glitz_surface_t *surface) {
-  glitz_gl_proc_address_list_t *gl = &surface->backend->gl;
-
-  if (SURFACE_DRAWABLE (surface)) {
-    glitz_bounding_box_t box;
+_glitz_surface_sync_drawable (glitz_surface_t *surface)
+{   
+  if (REGION_NOTEMPTY (&surface->drawable_damage)) {
+    glitz_texture_t *texture;
+    glitz_box_t     *box, *ext;
+    int             n_box;
+  
+    GLITZ_GL_SURFACE (surface);
 
-    box.x1 = box.y1 = 0;
-    box.x2 = box.y2 = 1;
+    texture = glitz_surface_get_texture (surface, 0);
+    if (!texture)
+      return;
     
-    gl->color_4us (surface->solid.red,
-                   surface->solid.green,
-                   surface->solid.blue,
-                   surface->solid.alpha);
+    box = REGION_RECTS (&surface->drawable_damage);
+    ext = REGION_EXTENTS (&surface->drawable_damage);
+    n_box = REGION_NUM_RECTS (&surface->drawable_damage);
+
+    glitz_texture_bind (gl, texture);
+  
+    glitz_texture_set_tex_gen (gl, texture, 0, 0, 0); 
     
-    glitz_set_operator (gl, GLITZ_OPERATOR_SRC);
+    gl->tex_env_f (GLITZ_GL_TEXTURE_ENV, GLITZ_GL_TEXTURE_ENV_MODE,
+                   GLITZ_GL_REPLACE);
+    gl->color_4us (0x0, 0x0, 0x0, 0xffff);
     
-    glitz_geometry_enable_default (gl, surface, &box);
+    glitz_texture_ensure_wrap (gl, texture, GLITZ_GL_CLAMP_TO_EDGE);
+    glitz_texture_ensure_filter (gl, texture, GLITZ_GL_NEAREST);
     
-    gl->draw_arrays (GLITZ_GL_QUADS, 0, 4);
+    glitz_set_operator (gl, GLITZ_OPERATOR_SRC);
     
-    glitz_geometry_disable (gl, surface);
-  } else {
-    glitz_gl_float_t color[4];
+    gl->scissor (surface->x + ext->x1,
+                 surface->attached->height - surface->y - ext->y2,
+                 ext->x2 - ext->x1,
+                 ext->y2 - ext->y1);
+
+    if (n_box > 1) {
+      glitz_float_t *data;
+      void          *ptr;
+      int           vertices;
+      
+      ptr = malloc (n_box * 8 * sizeof (glitz_float_t));
+      if (!ptr) {
+        glitz_surface_status_add (surface, GLITZ_STATUS_NO_MEMORY_MASK);
+        return;
+      }
 
-    if (TEXTURE_ALLOCATED (&surface->texture)) {
-      color[0] = surface->solid.red / 65535.0f;
-      color[1] = surface->solid.green / 65535.0f;
-      color[2] = surface->solid.blue / 65535.0f;
-      color[3] = surface->solid.alpha / 65535.0f;
-    
-      glitz_texture_bind (gl, &surface->texture);
-      gl->tex_sub_image_2d (surface->texture.target, 0,
-                            surface->texture.box.x1, surface->texture.box.y1,
-                            1, 1, GLITZ_GL_RGBA, GLITZ_GL_FLOAT, color);
-      glitz_texture_unbind (gl, &surface->texture);
+      data = (glitz_float_t *) ptr;
+      vertices = n_box << 2;
+
+      while (n_box--) {
+        *data++ = (glitz_float_t) box->x1;
+        *data++ = (glitz_float_t) box->y1;
+        *data++ = (glitz_float_t) box->x2;
+        *data++ = (glitz_float_t) box->y1;
+        *data++ = (glitz_float_t) box->x2;
+        *data++ = (glitz_float_t) box->y2;
+        *data++ = (glitz_float_t) box->x1;
+        *data++ = (glitz_float_t) box->y2;
+        
+        box++;
+      }
+
+      gl->vertex_pointer (2, GLITZ_GL_FLOAT, 0, ptr);
+      gl->draw_arrays (GLITZ_GL_QUADS, 0, vertices);
+      
+      free (ptr);
+    } else {
+      glitz_geometry_enable_default (gl, surface, ext);
+      gl->draw_arrays (GLITZ_GL_QUADS, 0, 4);
     }
+
+    glitz_texture_unbind (gl, texture);
+    
+    REGION_EMPTY (&surface->drawable_damage);
   }
-  surface->flags &= ~GLITZ_SURFACE_FLAG_DRAWABLE_DIRTY_MASK;
 }
 
 void
-glitz_surface_ensure_solid (glitz_surface_t *surface)
+glitz_surface_sync_solid (glitz_surface_t *surface)
 {
-  if (SURFACE_DIRTY (surface) || SURFACE_SOLID_DIRTY (surface)) {
-    glitz_gl_proc_address_list_t *gl = &surface->backend->gl;
+  if (SURFACE_SOLID_DAMAGE (surface)) {
     glitz_gl_float_t *c, color[64];
     glitz_texture_t *texture;
 
-    texture = glitz_surface_get_texture (surface, 0);
+    GLITZ_GL_SURFACE (surface);
 
+    texture = glitz_surface_get_texture (surface, 0);
+    
     c = &color[(texture->box.y1 * texture->width + texture->box.x1) * 4];
     if (texture) {
       glitz_texture_bind (gl, texture);
@@ -205,37 +294,257 @@ glitz_surface_ensure_solid (glitz_surface_t *surface)
       c[0] = c[1] = c[2] = 0.0f;
       c[3] = 1.0f;
     }
-  
+    
     surface->solid.red = c[0] * 65535.0f;
     surface->solid.green = c[1] * 65535.0f;
     surface->solid.blue = c[2] * 65535.0f;
     surface->solid.alpha = c[3] * 65535.0f;
 
-    surface->flags &= ~GLITZ_SURFACE_FLAG_SOLID_DIRTY_MASK;
+    surface->flags &= ~GLITZ_SURFACE_FLAG_SOLID_DAMAGE_MASK;
   }
 }
 
-glitz_bool_t
-glitz_surface_push_current (glitz_surface_t *surface,
-                            glitz_constraint_t constraint)
+glitz_texture_t *
+glitz_surface_get_texture (glitz_surface_t *surface,
+                           glitz_bool_t    allocate)
+{
+  GLITZ_GL_SURFACE (surface);
+
+  if (REGION_NOTEMPTY (&surface->texture_damage)) {
+    _glitz_surface_sync_texture (surface);
+  } else if (allocate) {
+    if (!(TEXTURE_ALLOCATED (&surface->texture)))
+      glitz_texture_allocate (gl, &surface->texture);
+  }
+  
+  if (TEXTURE_ALLOCATED (&surface->texture))
+    return &surface->texture;
+  
+  return NULL;
+}
+
+void
+glitz_surface_damage (glitz_surface_t *surface,
+                      glitz_box_t     *box,
+                      int             what)
+{
+  glitz_box_t b;
+
+  if (box) {
+    b.x1 = MAX (0, box->x1);
+    b.y1 = MAX (0, box->y1);
+    b.x2 = MIN (surface->width, box->x2);
+    b.y2 = MIN (surface->height, box->y2);
+
+    if (b.x1 >= b.x2 || b.y1 >= b.y2)
+      return;
+    
+    if (what & GLITZ_DAMAGE_DRAWABLE_MASK)
+      REGION_UNION (&surface->drawable_damage, &b);
+
+    if (what & GLITZ_DAMAGE_TEXTURE_MASK)
+      REGION_UNION (&surface->texture_damage, &b);
+  } else {
+    b.x1 = b.y1 = 0;
+    b.x2 = surface->width;
+    b.y2 = surface->height;
+
+    if (what & GLITZ_DAMAGE_DRAWABLE_MASK) {
+      REGION_EMPTY (&surface->drawable_damage);
+      REGION_INIT (&surface->drawable_damage, &b);
+    }
+
+    if (what & GLITZ_DAMAGE_TEXTURE_MASK) {
+      REGION_EMPTY (&surface->texture_damage);
+      REGION_INIT (&surface->texture_damage, &b);
+    }
+  }
+
+  if (what & GLITZ_DAMAGE_SOLID_MASK)
+    surface->flags |= GLITZ_SURFACE_FLAG_SOLID_DAMAGE_MASK;
+}
+
+void
+glitz_surface_status_add (glitz_surface_t *surface, int flags)
+{
+  surface->status_mask |= flags;
+}
+
+static void
+_glitz_surface_update_state (glitz_surface_t *surface)
 {
-  if (!surface->backend->push_current (surface, constraint))
-    return 0;
+  glitz_rectangle_t *viewport;
+  
+  GLITZ_GL_SURFACE (surface);
+
+  viewport = &surface->attached->viewport;
+  
+  if (surface->attached->update_all ||
+      viewport->x != surface->x ||
+      viewport->y != surface->y ||
+      viewport->width != surface->width ||
+      viewport->height != surface->height) {
+    gl->viewport (surface->x,
+                  surface->attached->height - surface->y - surface->height,
+                  surface->width,
+                  surface->height);
+    gl->matrix_mode (GLITZ_GL_PROJECTION);
+    gl->load_identity ();
+    gl->ortho (0.0,
+               surface->width,
+               surface->attached->height - surface->height,
+               surface->attached->height,
+               -1.0, 1.0);
+    gl->matrix_mode (GLITZ_GL_MODELVIEW);
+    gl->load_identity ();
+    gl->scale_f (1.0f, -1.0f, 1.0f);
+    gl->translate_f (0.0f, -surface->attached->height, 0.0f);
+    
+    viewport->x = surface->x;
+    viewport->y = surface->y;
+    viewport->width = surface->width;
+    viewport->height = surface->height;
+    
+    surface->attached->update_all = 0;
+  }
+
+  gl->draw_buffer (surface->buffer);
 
-  if (SURFACE_SOLID (surface) && SURFACE_DRAWABLE_DIRTY (surface))
-    _glitz_surface_solid_store (surface);
+  if (SURFACE_DITHER (surface))
+    gl->enable (GLITZ_GL_DITHER);
+  else
+    gl->disable (GLITZ_GL_DITHER);
 
+  if (surface->attached->format->samples > 1) {
+    if (SURFACE_MULTISAMPLE (surface)) {
+      gl->enable (GLITZ_GL_MULTISAMPLE);
+      
+      if (surface->attached->backend->feature_mask &
+          GLITZ_FEATURE_MULTISAMPLE_FILTER_HINT_MASK) {
+        if (SURFACE_NICEST_MULTISAMPLE (surface))
+          gl->hint (GLITZ_GL_MULTISAMPLE_FILTER_HINT, GLITZ_GL_NICEST);
+        else
+          gl->hint (GLITZ_GL_MULTISAMPLE_FILTER_HINT, GLITZ_GL_FASTEST);
+      }
+    } else
+      gl->disable (GLITZ_GL_MULTISAMPLE);
+  }
+}
+
+void
+glitz_surface_attach (glitz_surface_t         *surface,
+                      glitz_drawable_t        *drawable,
+                      glitz_drawable_buffer_t buffer,
+                      int                     x,
+                      int                     y)
+{
+  glitz_drawable_reference (drawable);
+
+  if (surface->attached)
+    glitz_drawable_destroy (surface->attached);
+  
+  surface->attached = drawable;
+  surface->x = x;
+  surface->y = y;
+
+  switch (buffer) {
+  case GLITZ_DRAWABLE_BUFFER_FRONT_COLOR:
+    surface->buffer = GLITZ_GL_FRONT;
+    break;
+  case GLITZ_DRAWABLE_BUFFER_BACK_COLOR:
+    surface->buffer = GLITZ_GL_BACK;
+    break;
+  }
+
+  if ((!SURFACE_SOLID (surface)) || SURFACE_SOLID_DAMAGE (surface))
+    REGION_EMPTY (&surface->texture_damage);
+}
+
+void
+glitz_surface_detach (glitz_surface_t *surface)
+{
+  glitz_box_t box;
+
+  if (!surface->attached)
+    return;
+
+  if (REGION_NOTEMPTY (&surface->texture_damage)) {
+    glitz_surface_push_current (surface, GLITZ_DRAWABLE_CURRENT);
+    _glitz_surface_sync_texture (surface);
+    glitz_surface_pop_current (surface);
+  }
+  
+  glitz_drawable_destroy (surface->attached); 
+  surface->attached = NULL;
+
+  box.x1 = box.y1 = 0;
+  box.x2 = surface->width;
+  box.y2 = surface->height;
+    
+  REGION_EMPTY (&surface->drawable_damage);
+  REGION_INIT (&surface->drawable_damage, &box);
+}
+
+glitz_drawable_t *
+glitz_surface_get_drawable (glitz_surface_t *surface)
+{
+  return surface->drawable;
+}
+slim_hidden_def(glitz_surface_get_drawable);
+
+glitz_drawable_t *
+glitz_surface_get_attached_drawable (glitz_surface_t *surface)
+{
+  return surface->attached;
+}
+slim_hidden_def(glitz_surface_get_attached_drawable);
+
+glitz_bool_t
+glitz_surface_push_current (glitz_surface_t    *surface,
+                            glitz_constraint_t constraint)
+{
+  if (surface->attached) {
+    surface->attached->backend->push_current (surface->attached, surface,
+                                              constraint);
+    if (constraint == GLITZ_DRAWABLE_CURRENT) {
+      _glitz_surface_update_state (surface);
+      _glitz_surface_sync_drawable (surface);
+    }
+  } else {
+    surface->drawable->backend->push_current (surface->drawable, NULL,
+                                              constraint);
+    if (constraint == GLITZ_DRAWABLE_CURRENT)
+      return 0;
+  }
+  
   return 1;
 }
 
 void
 glitz_surface_pop_current (glitz_surface_t *surface)
 {
-  surface->backend->pop_current (surface);
+  glitz_surface_t *other;
+  
+  if (surface->attached)
+    other = surface->attached->backend->pop_current (surface->attached);
+  else
+    other = surface->drawable->backend->pop_current (surface->drawable);
+
+  if (other)
+    _glitz_surface_update_state (other);
+}
+
+glitz_status_t
+glitz_surface_make_current_read (glitz_surface_t *surface)
+{
+  if (surface->attached)
+    return surface->attached->backend->make_current_read (surface->attached);
+  else
+    return surface->drawable->backend->make_current_read (surface->drawable);
 }
 
 void
-glitz_surface_set_transform (glitz_surface_t *surface,
+glitz_surface_set_transform (glitz_surface_t   *surface,
                              glitz_transform_t *transform)
 {
   static glitz_transform_t identity = {
@@ -357,7 +666,7 @@ slim_hidden_def(glitz_surface_set_transform);
 
 void
 glitz_surface_set_fill (glitz_surface_t *surface,
-                        glitz_fill_t fill)
+                        glitz_fill_t    fill)
 {
   switch (fill) {
   case GLITZ_FILL_TRANSPARENT:
@@ -388,9 +697,9 @@ slim_hidden_def(glitz_surface_set_fill);
 
 void
 glitz_surface_set_component_alpha (glitz_surface_t *surface,
-                                   glitz_bool_t component_alpha)
+                                   glitz_bool_t    component_alpha)
 {
-  if (component_alpha && surface->format->red_size)
+  if (component_alpha && surface->format->color.red_size)
     surface->flags |= GLITZ_SURFACE_FLAG_COMPONENT_ALPHA_MASK;
   else
     surface->flags &= ~GLITZ_SURFACE_FLAG_COMPONENT_ALPHA_MASK;
@@ -398,10 +707,10 @@ glitz_surface_set_component_alpha (glitz_surface_t *surface,
 slim_hidden_def(glitz_surface_set_component_alpha);
 
 void
-glitz_surface_set_filter (glitz_surface_t *surface,
-                          glitz_filter_t filter,
+glitz_surface_set_filter (glitz_surface_t    *surface,
+                          glitz_filter_t     filter,
                           glitz_fixed16_16_t *params,
-                          int n_params)
+                          int                n_params)
 {
   glitz_status_t status;
   
@@ -442,143 +751,40 @@ glitz_surface_set_filter (glitz_surface_t *surface,
 }
 slim_hidden_def(glitz_surface_set_filter);
 
-int
-glitz_surface_get_width (glitz_surface_t *surface)
-{
-  return surface->width;
-}
-slim_hidden_def(glitz_surface_get_width);
-
-int
-glitz_surface_get_height (glitz_surface_t *surface)
-{
-  return surface->height;
-}
-slim_hidden_def(glitz_surface_get_height);
-
-glitz_texture_t *
-glitz_surface_get_texture (glitz_surface_t *surface,
-                           glitz_bool_t allocate)
-{
-  glitz_texture_t *texture;
-
-  if (SURFACE_SOLID (surface) && SURFACE_DRAWABLE_DIRTY (surface)) {
-    texture = surface->backend->get_texture (surface, 1);
-    _glitz_surface_solid_store (surface);
-  } else
-    texture = surface->backend->get_texture (surface, allocate);
-
-  return texture;
-}
-
-static glitz_gl_enum_t
-_gl_color_buffer (glitz_color_buffer_t buffer)
-{
-  switch (buffer) {
-  case GLITZ_COLOR_BUFFER_FRONT:
-    return GLITZ_GL_FRONT;
-  case GLITZ_COLOR_BUFFER_BACK:
-    return GLITZ_GL_BACK;
-  default:
-    return GLITZ_GL_BACK;
-  }
-}
-
-void
-glitz_surface_set_read_color_buffer (glitz_surface_t *surface,
-                                     glitz_color_buffer_t buffer)
-{
-  glitz_gl_enum_t mode;
-  
-  if (!surface->format->doublebuffer)
-    return;
-    
-  mode = _gl_color_buffer (buffer);
-  if (mode != surface->read_buffer) {
-    surface->read_buffer = mode;
-    glitz_surface_dirty (surface, NULL);
-  }
-}
-slim_hidden_def(glitz_surface_set_read_color_buffer);
-
 void
-glitz_surface_set_draw_color_buffer (glitz_surface_t *surface,
-                                     glitz_color_buffer_t buffer)
+glitz_surface_set_dither (glitz_surface_t *surface,
+                          glitz_bool_t    dither)
 {
-  if (!surface->format->doublebuffer)
-    return;
-
-  surface->draw_buffer = _gl_color_buffer (buffer);
-
-  surface->update_mask |= GLITZ_UPDATE_DRAW_BUFFER_MASK;
-}
-slim_hidden_def(glitz_surface_set_draw_color_buffer);
-
-void
-glitz_surface_swap_buffers (glitz_surface_t *surface)
-{
-  if (!surface->format->doublebuffer)
-    return;
-  
-  surface->backend->swap_buffers (surface);
+  if (dither)
+    surface->flags |= GLITZ_SURFACE_FLAG_DITHER_MASK;
+  else
+    surface->flags &= ~GLITZ_SURFACE_FLAG_DITHER_MASK;
 }
-slim_hidden_def(glitz_surface_swap_buffers);
+slim_hidden_def(glitz_surface_set_dither);
 
 void
 glitz_surface_flush (glitz_surface_t *surface)
 {
-  if (glitz_surface_push_current (surface, GLITZ_CN_SURFACE_DRAWABLE_CURRENT))
-    surface->backend->gl.flush ();
-  
-  glitz_surface_pop_current (surface);
+  if (surface->attached && REGION_NOTEMPTY (&surface->drawable_damage)) {
+    glitz_surface_push_current (surface, GLITZ_DRAWABLE_CURRENT);
+    glitz_surface_pop_current (surface);
+  }
 }
 slim_hidden_def(glitz_surface_flush);
 
-void
-glitz_surface_finish (glitz_surface_t *surface)
-{
-  if (glitz_surface_push_current (surface, GLITZ_CN_SURFACE_DRAWABLE_CURRENT))
-    surface->backend->gl.finish ();
-  
-  glitz_surface_pop_current (surface);
-}
-slim_hidden_def(glitz_surface_finish);
-
-glitz_bool_t
-glitz_surface_make_current_read (glitz_surface_t *surface)
+unsigned int
+glitz_surface_get_width (glitz_surface_t *surface)
 {
-  return surface->backend->make_current_read (surface);
-}
-
-void
-glitz_surface_dirty (glitz_surface_t *surface,
-                     glitz_bounding_box_t *box)
-{ 
-  if (surface->draw_buffer != surface->read_buffer)
-    return;
-  
-  if (!box) {
-    surface->dirty_box.x1 = surface->dirty_box.y1 = 0;
-    surface->dirty_box.x2 = surface->width;
-    surface->dirty_box.y2 = surface->height;
-  } else {
-    if (!SURFACE_DIRTY (surface)) {
-      surface->dirty_box = *box;
-    } else
-      glitz_union_bounding_box (box,
-                                &surface->dirty_box,
-                                &surface->dirty_box);
-  }
-  
-  surface->flags |=
-    (GLITZ_SURFACE_FLAG_DIRTY_MASK | GLITZ_SURFACE_FLAG_SOLID_DIRTY_MASK);
+  return (unsigned int) surface->width;
 }
+slim_hidden_def(glitz_surface_get_width);
 
-void
-glitz_surface_status_add (glitz_surface_t *surface, int flags)
+unsigned int
+glitz_surface_get_height (glitz_surface_t *surface)
 {
-  surface->status_mask |= flags;
+  return (unsigned int) surface->height;
 }
+slim_hidden_def(glitz_surface_get_height);
 
 glitz_status_t
 glitz_surface_get_status (glitz_surface_t *surface)
@@ -587,72 +793,6 @@ glitz_surface_get_status (glitz_surface_t *surface)
 }
 slim_hidden_def(glitz_surface_get_status);
 
-void
-glitz_surface_update_state (glitz_surface_t *surface)
-{
-  glitz_gl_proc_address_list_t *gl = &surface->backend->gl;
-  
-  if (surface->update_mask & GLITZ_UPDATE_VIEWPORT_MASK) {
-    gl->viewport (0, 0, surface->width, surface->height);
-    gl->matrix_mode (GLITZ_GL_PROJECTION);
-    gl->load_identity ();
-    gl->ortho (0.0, surface->width, 0.0, surface->height, -1.0, 1.0);
-    gl->matrix_mode (GLITZ_GL_MODELVIEW);
-    gl->load_identity ();
-    gl->scale_f (1.0f, -1.0f, 1.0f);
-    gl->translate_f (0.0f, -surface->height, 0.0f);
-    gl->disable (GLITZ_GL_DEPTH_TEST); 
-    gl->hint (GLITZ_GL_PERSPECTIVE_CORRECTION_HINT, GLITZ_GL_FASTEST);
-    gl->disable (GLITZ_GL_CULL_FACE);
-    gl->depth_mask (GLITZ_GL_FALSE);  
-    gl->polygon_mode (GLITZ_GL_FRONT_AND_BACK, GLITZ_GL_FILL);
-    gl->disable (GLITZ_GL_POLYGON_SMOOTH);
-    gl->shade_model (GLITZ_GL_FLAT);
-    gl->color_mask (GLITZ_GL_TRUE, GLITZ_GL_TRUE, GLITZ_GL_TRUE,
-                    GLITZ_GL_TRUE);
-    gl->disable (GLITZ_GL_DITHER);
-    gl->enable (GLITZ_GL_SCISSOR_TEST);
-    gl->scissor (0, 0, surface->width, surface->height);
-    gl->disable (GLITZ_GL_STENCIL_TEST);
-    gl->enable_client_state (GLITZ_GL_VERTEX_ARRAY);
-    
-    surface->update_mask &= ~GLITZ_UPDATE_VIEWPORT_MASK;
-  }
-  
-  if (surface->update_mask & GLITZ_UPDATE_DRAW_BUFFER_MASK) {
-    if (surface->format->doublebuffer)
-      gl->draw_buffer (surface->draw_buffer);
-    
-    surface->update_mask &= ~GLITZ_UPDATE_DRAW_BUFFER_MASK;
-  }
-
-  if (surface->update_mask & GLITZ_UPDATE_MULTISAMPLE_MASK) {
-    if (surface->format->multisample.samples) {
-      if (SURFACE_MULTISAMPLE (surface)) {
-        gl->enable (GLITZ_GL_MULTISAMPLE);
-        
-        if (surface->backend->feature_mask &
-            GLITZ_FEATURE_MULTISAMPLE_FILTER_HINT_MASK) {
-          if (SURFACE_NICEST_MULTISAMPLE (surface))
-            gl->hint (GLITZ_GL_MULTISAMPLE_FILTER_HINT, GLITZ_GL_NICEST);
-          else
-            gl->hint (GLITZ_GL_MULTISAMPLE_FILTER_HINT, GLITZ_GL_FASTEST);
-        }
-      } else
-        gl->disable (GLITZ_GL_MULTISAMPLE);
-    }
-    
-    surface->update_mask &= ~GLITZ_UPDATE_MULTISAMPLE_MASK;
-  }
-}
-
-unsigned long
-glitz_surface_get_features (glitz_surface_t *surface)
-{
-  return surface->backend->feature_mask;
-}
-slim_hidden_def(glitz_surface_get_features);
-
 glitz_format_t *
 glitz_surface_get_format (glitz_surface_t *surface)
 {
diff --git a/src/glitz_texture.c b/src/glitz_texture.c
index 321be90..f4f25b2 100644
--- a/src/glitz_texture.c
+++ b/src/glitz_texture.c
@@ -1,28 +1,26 @@
 /*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
+ * Copyright © 2004 David Reveman
+ * 
  * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
  *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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.
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
+ * Author: David Reveman <c99drn@cs.umu.se>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -33,10 +31,10 @@
 
 void
 glitz_texture_init (glitz_texture_t *texture,
-                    unsigned int width,
-                    unsigned int height,
-                    unsigned int texture_format,
-                    unsigned long feature_mask)
+                    int             width,
+                    int             height,
+                    glitz_gl_int_t  texture_format,
+                    unsigned long   feature_mask)
 {
   texture->filter = 0;
   texture->wrap = 0;
@@ -89,9 +87,9 @@ glitz_texture_init (glitz_texture_t *texture,
 
 void
 glitz_texture_size_check (glitz_gl_proc_address_list_t *gl,
-                          glitz_texture_t *texture,
-                          glitz_gl_int_t max_2d,
-                          glitz_gl_int_t max_rect) {
+                          glitz_texture_t              *texture,
+                          glitz_gl_int_t               max_2d,
+                          glitz_gl_int_t               max_rect) {
   glitz_gl_enum_t proxy_target;
   glitz_gl_int_t value, max;
 
@@ -126,7 +124,7 @@ glitz_texture_size_check (glitz_gl_proc_address_list_t *gl,
 
 void
 glitz_texture_allocate (glitz_gl_proc_address_list_t *gl,
-                        glitz_texture_t *texture)
+                        glitz_texture_t              *texture)
 {
   char *data = NULL;
   
@@ -162,7 +160,7 @@ glitz_texture_allocate (glitz_gl_proc_address_list_t *gl,
 
 void 
 glitz_texture_fini (glitz_gl_proc_address_list_t *gl,
-                    glitz_texture_t *texture)
+                    glitz_texture_t              *texture)
 {
   if (texture->name)
     gl->delete_textures (1, &texture->name);
@@ -170,8 +168,8 @@ glitz_texture_fini (glitz_gl_proc_address_list_t *gl,
 
 void
 glitz_texture_ensure_filter (glitz_gl_proc_address_list_t *gl,
-                             glitz_texture_t *texture,
-                             glitz_gl_enum_t filter)
+                             glitz_texture_t              *texture,
+                             glitz_gl_enum_t              filter)
 {
   if (!texture->name)
     return;
@@ -185,8 +183,8 @@ glitz_texture_ensure_filter (glitz_gl_proc_address_list_t *gl,
 
 void
 glitz_texture_ensure_wrap (glitz_gl_proc_address_list_t *gl,
-                           glitz_texture_t *texture,
-                           glitz_gl_enum_t wrap)
+                           glitz_texture_t              *texture,
+                           glitz_gl_enum_t              wrap)
 {
   if (!texture->name)
     return;
@@ -200,7 +198,7 @@ glitz_texture_ensure_wrap (glitz_gl_proc_address_list_t *gl,
 
 void
 glitz_texture_bind (glitz_gl_proc_address_list_t *gl,
-                    glitz_texture_t *texture)
+                    glitz_texture_t              *texture)
 {  
   gl->disable (GLITZ_GL_TEXTURE_RECTANGLE);
   gl->disable (GLITZ_GL_TEXTURE_2D);
@@ -214,48 +212,37 @@ glitz_texture_bind (glitz_gl_proc_address_list_t *gl,
 
 void
 glitz_texture_unbind (glitz_gl_proc_address_list_t *gl,
-                      glitz_texture_t *texture)
+                      glitz_texture_t              *texture)
 {
   gl->bind_texture (texture->target, 0);
   gl->disable (texture->target);
 }
 
 void
-glitz_texture_copy_surface (glitz_texture_t *texture,
-                            glitz_surface_t *surface,
-                            int x_surface,
-                            int y_surface,
-                            int width,
-                            int height,
-                            int x_texture,
-                            int y_texture)
+glitz_texture_copy_drawable (glitz_gl_proc_address_list_t *gl,
+                             glitz_texture_t              *texture,
+                             glitz_drawable_t             *drawable,
+                             int                          x_drawable,
+                             int                          y_drawable,
+                             int                          width,
+                             int                          height,
+                             int                          x_texture,
+                             int                          y_texture)
 {
-  glitz_gl_proc_address_list_t *gl = &surface->backend->gl;
-  
-  glitz_surface_push_current (surface, GLITZ_CN_SURFACE_DRAWABLE_CURRENT);
-  
-  glitz_texture_bind (gl, texture);
-
-  if (surface->format->doublebuffer)
-    gl->read_buffer (surface->read_buffer);
-
   gl->copy_tex_sub_image_2d (texture->target, 0,
                              texture->box.x1 + x_texture,
                              texture->box.y2 - y_texture - height,
-                             x_surface,
-                             surface->height - y_surface - height,
+                             x_drawable,
+                             drawable->height - y_drawable - height,
                              width, height);
-
-  glitz_texture_unbind (gl, texture);
-  glitz_surface_pop_current (surface);
 }
 
 void
 glitz_texture_set_tex_gen (glitz_gl_proc_address_list_t *gl,
-                           glitz_texture_t *texture,
-                           int x_src,
-                           int y_src,
-                           unsigned long flags)
+                           glitz_texture_t              *texture,
+                           int                          x_src,
+                           int                          y_src,
+                           unsigned long                flags)
 {
   glitz_vec4_t plane;
 
diff --git a/src/glitz_util.c b/src/glitz_util.c
index 5cbee66..853eb7c 100644
--- a/src/glitz_util.c
+++ b/src/glitz_util.c
@@ -1,28 +1,26 @@
 /*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
+ * Copyright © 2004 David Reveman
+ * 
  * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
  *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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.
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
+ * Author: David Reveman <c99drn@cs.umu.se>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -34,33 +32,35 @@
 #include <stdlib.h>
 #include <string.h>
 
-void
-glitz_intersect_bounding_box (glitz_bounding_box_t *box1,
-                              glitz_bounding_box_t *box2,
-                              glitz_bounding_box_t *return_box)
-{
-  return_box->x1 = (box1->x1 >= box2->x1)? box1->x1: box2->x1;
-  return_box->x2 = (box1->x2 <= box2->x2)? box1->x2: box2->x2;
-  return_box->y1 = (box1->y1 >= box2->y1)? box1->y1: box2->y1;
-  return_box->y2 = (box1->y2 <= box2->y2)? box1->y2: box2->y2;
-
-  if (return_box->x1 >= return_box->x2)
-    return_box->x1 = return_box->x2 = 0;
-  
-  if (return_box->y1 >= return_box->y2)
-    return_box->y1 = return_box->y2 = 0;
-}
-
-void
-glitz_union_bounding_box (glitz_bounding_box_t *box1,
-                          glitz_bounding_box_t *box2,
-                          glitz_bounding_box_t *return_box)
-{
-  return_box->x1 = (box1->x1 <= box2->x1)? box1->x1: box2->x1;
-  return_box->x2 = (box1->x2 >= box2->x2)? box1->x2: box2->x2;
-  return_box->y1 = (box1->y1 <= box2->y1)? box1->y1: box2->y1;
-  return_box->y2 = (box1->y2 >= box2->y2)? box1->y2: box2->y2;
-}
+static glitz_extension_map gl_extensions[] = {
+  { 0.0, "GL_ARB_texture_rectangle", GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK },
+  { 0.0, "GL_EXT_texture_rectangle", GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK },
+  { 0.0, "GL_NV_texture_rectangle", GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK },
+  { 0.0, "GL_ARB_texture_non_power_of_two",
+    GLITZ_FEATURE_TEXTURE_NON_POWER_OF_TWO_MASK },
+  { 0.0, "GL_ARB_texture_mirrored_repeat",
+    GLITZ_FEATURE_TEXTURE_MIRRORED_REPEAT_MASK },
+  { 0.0, "GL_ARB_texture_border_clamp",
+    GLITZ_FEATURE_TEXTURE_BORDER_CLAMP_MASK },
+  { 0.0, "GL_ARB_texture_env_combine",
+    GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK },
+  { 0.0, "GL_EXT_texture_env_combine",
+    GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK },
+  { 0.0, "GL_ARB_texture_env_dot3", GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK },
+  { 0.0, "GL_ARB_multisample", GLITZ_FEATURE_MULTISAMPLE_MASK },
+  { 0.0, "GL_NV_multisample_filter_hint",
+    GLITZ_FEATURE_MULTISAMPLE_FILTER_HINT_MASK },
+  { 0.0, "GL_ARB_multitexture", GLITZ_FEATURE_MULTITEXTURE_MASK },
+  { 0.0, "GL_ARB_fragment_program", GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK },
+  { 0.0, "GL_ARB_vertex_buffer_object",
+    GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK },
+  { 0.0, "GL_EXT_pixel_buffer_object",
+    GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK },
+  { 0.0, "GL_EXT_blend_color", GLITZ_FEATURE_BLEND_COLOR_MASK },
+  { 0.0, "GL_ARB_imaging", GLITZ_FEATURE_BLEND_COLOR_MASK },
+  { 0.0, "GL_APPLE_packed_pixels", GLITZ_FEATURE_PACKED_PIXELS_MASK },
+  { 0.0, NULL, 0 }
+};
 
 static glitz_bool_t
 _glitz_extension_check (const char *extensions,
@@ -87,8 +87,8 @@ _glitz_extension_check (const char *extensions,
 }
 
 unsigned long
-glitz_extensions_query (glitz_gl_float_t version,
-                        const char *extensions_string,
+glitz_extensions_query (glitz_gl_float_t    version,
+                        const char          *extensions_string,
                         glitz_extension_map *extensions_map)
 {
   unsigned long mask = 0;
@@ -103,6 +103,167 @@ glitz_extensions_query (glitz_gl_float_t version,
   return mask;
 }
 
+static glitz_status_t
+_glitz_query_gl_extensions (glitz_gl_proc_address_list_t *gl,
+                            glitz_gl_float_t             *gl_version,
+                            unsigned long                *feature_mask)
+{
+  const char *gl_extensions_string;
+
+  *gl_version = atof ((const char *) gl->get_string (GLITZ_GL_VERSION));
+  if (*gl_version < 1.2f)
+    return GLITZ_STATUS_NOT_SUPPORTED;
+  
+  gl_extensions_string = (const char *) gl->get_string (GLITZ_GL_EXTENSIONS);
+  
+  *feature_mask = glitz_extensions_query (*gl_version,
+                                          gl_extensions_string,
+                                          gl_extensions);
+  
+  if ((*feature_mask & GLITZ_FEATURE_TEXTURE_ENV_COMBINE_MASK) &&
+      (*feature_mask & GLITZ_FEATURE_TEXTURE_ENV_DOT3_MASK)) {
+    glitz_gl_int_t max_texture_units;
+    
+    gl->get_integer_v (GLITZ_GL_MAX_TEXTURE_UNITS, &max_texture_units);
+    if (max_texture_units >= 3)
+      *feature_mask |= GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK;
+  }
+
+  return GLITZ_STATUS_SUCCESS;
+}
+
+static void
+_glitz_gl_proc_address_lookup (glitz_backend_t               *backend,
+                               glitz_get_proc_address_proc_t get_proc_address,
+                               void                          *closure)
+{
+  if (backend->feature_mask & GLITZ_FEATURE_BLEND_COLOR_MASK) {
+    if (backend->gl_version >= 1.4f) {
+      backend->gl.blend_color = (glitz_gl_blend_color_t)
+        get_proc_address ("glBlendColor", closure);
+    } else {
+      backend->gl.blend_color = (glitz_gl_blend_color_t)
+        get_proc_address ("glBlendColorEXT", closure);
+    }
+
+    if (!backend->gl.blend_color)
+      backend->feature_mask &= ~GLITZ_FEATURE_BLEND_COLOR_MASK;
+  }
+
+  if (backend->feature_mask & GLITZ_FEATURE_MULTITEXTURE_MASK) {
+    if (backend->gl_version >= 1.3f) {
+      backend->gl.active_texture = (glitz_gl_active_texture_t)
+        get_proc_address ("glActiveTexture", closure);
+    } else {
+      backend->gl.active_texture = (glitz_gl_active_texture_t)
+        get_proc_address ("glActiveTextureARB", closure);
+    }
+
+    if (!backend->gl.active_texture) {
+      backend->feature_mask &= ~GLITZ_FEATURE_MULTITEXTURE_MASK;
+      backend->feature_mask &= ~GLITZ_FEATURE_PER_COMPONENT_RENDERING_MASK;
+    }
+  }
+
+  if (backend->feature_mask & GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK) {
+    backend->gl.gen_programs = (glitz_gl_gen_programs_t)
+      get_proc_address ("glGenProgramsARB", closure);
+    backend->gl.delete_programs = (glitz_gl_delete_programs_t)
+      get_proc_address ("glDeleteProgramsARB", closure);
+    backend->gl.program_string = (glitz_gl_program_string_t)
+      get_proc_address ("glProgramStringARB", closure);
+    backend->gl.bind_program = (glitz_gl_bind_program_t)
+      get_proc_address ("glBindProgramARB", closure);
+    backend->gl.program_local_param_4fv = (glitz_gl_program_local_param_4fv_t)
+      get_proc_address ("glProgramLocalParameter4fvARB", closure);
+    backend->gl.get_program_iv = (glitz_gl_get_program_iv_t)
+      get_proc_address ("glGetProgramivARB", closure);
+
+    if ((!backend->gl.gen_programs) ||
+        (!backend->gl.delete_programs) ||
+        (!backend->gl.program_string) ||
+        (!backend->gl.bind_program) ||
+        (!backend->gl.program_local_param_4fv))
+      backend->feature_mask &= ~GLITZ_FEATURE_FRAGMENT_PROGRAM_MASK;
+  }
+
+  if ((backend->feature_mask & GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK) ||
+      (backend->feature_mask & GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK)) {
+    if (backend->gl_version >= 1.5f) {
+      backend->gl.gen_buffers = (glitz_gl_gen_buffers_t)
+        get_proc_address ("glGenBuffers", closure);
+      backend->gl.delete_buffers = (glitz_gl_delete_buffers_t)
+        get_proc_address ("glDeleteBuffers", closure);
+      backend->gl.bind_buffer = (glitz_gl_bind_buffer_t)
+        get_proc_address ("glBindBuffer", closure);
+      backend->gl.buffer_data = (glitz_gl_buffer_data_t)
+        get_proc_address ("glBufferData", closure);
+      backend->gl.buffer_sub_data = (glitz_gl_buffer_sub_data_t)
+        get_proc_address ("glBufferSubData", closure);
+      backend->gl.get_buffer_sub_data = (glitz_gl_get_buffer_sub_data_t)
+        get_proc_address ("glGetBufferSubData", closure);
+      backend->gl.map_buffer = (glitz_gl_map_buffer_t)
+        get_proc_address ("glMapBuffer", closure);
+      backend->gl.unmap_buffer = (glitz_gl_unmap_buffer_t)
+        get_proc_address ("glUnmapBuffer", closure);
+    } else {
+      backend->gl.gen_buffers = (glitz_gl_gen_buffers_t)
+        get_proc_address ("glGenBuffersARB", closure);
+      backend->gl.delete_buffers = (glitz_gl_delete_buffers_t)
+        get_proc_address ("glDeleteBuffersARB", closure);
+      backend->gl.bind_buffer = (glitz_gl_bind_buffer_t)
+        get_proc_address ("glBindBufferARB", closure);
+      backend->gl.buffer_data = (glitz_gl_buffer_data_t)
+        get_proc_address ("glBufferDataARB", closure);
+      backend->gl.buffer_sub_data = (glitz_gl_buffer_sub_data_t)
+        get_proc_address ("glBufferSubDataARB", closure);
+      backend->gl.get_buffer_sub_data = (glitz_gl_get_buffer_sub_data_t)
+        get_proc_address ("glGetBufferSubDataARB", closure);
+      backend->gl.map_buffer = (glitz_gl_map_buffer_t)
+        get_proc_address ("glMapBufferARB", closure);
+      backend->gl.unmap_buffer = (glitz_gl_unmap_buffer_t)
+        get_proc_address ("glUnmapBufferARB", closure);
+    }
+
+    if ((!backend->gl.gen_buffers) ||
+        (!backend->gl.delete_buffers) ||
+        (!backend->gl.bind_buffer) ||
+        (!backend->gl.buffer_data) ||
+        (!backend->gl.buffer_sub_data) ||
+        (!backend->gl.get_buffer_sub_data) ||
+        (!backend->gl.map_buffer) ||
+        (!backend->gl.unmap_buffer)) {
+      backend->feature_mask &= ~GLITZ_FEATURE_VERTEX_BUFFER_OBJECT_MASK;
+      backend->feature_mask &= ~GLITZ_FEATURE_PIXEL_BUFFER_OBJECT_MASK;
+    }
+  }
+}
+
+void
+glitz_backend_init (glitz_backend_t               *backend,
+                    glitz_get_proc_address_proc_t get_proc_address,
+                    void                          *closure)
+{
+  if (!_glitz_query_gl_extensions (&backend->gl,
+                                   &backend->gl_version,
+                                   &backend->feature_mask)) {
+    _glitz_gl_proc_address_lookup (backend, get_proc_address, closure);
+    glitz_create_surface_formats (&backend->gl,
+                                  &backend->formats,
+                                  &backend->texture_formats,
+                                  &backend->n_formats);
+  }
+  
+  backend->gl.get_integer_v (GLITZ_GL_MAX_TEXTURE_SIZE,
+                             &backend->max_texture_2d_size);
+  
+  if (backend->feature_mask & GLITZ_FEATURE_TEXTURE_RECTANGLE_MASK)
+    backend->gl.get_integer_v (GLITZ_GL_MAX_RECTANGLE_TEXTURE_SIZE,
+                               &backend->max_texture_rect_size);
+  else
+    backend->max_texture_rect_size = 0;
+}
+
 unsigned int
 glitz_uint_to_power_of_two (unsigned int x)
 {
@@ -117,8 +278,8 @@ glitz_uint_to_power_of_two (unsigned int x)
 
 void
 glitz_set_raster_pos (glitz_gl_proc_address_list_t *gl,
-                      int x,
-                      int y)
+                      int                          x,
+                      int                          y)
 {
   gl->push_attrib (GLITZ_GL_TRANSFORM_BIT | GLITZ_GL_VIEWPORT_BIT);
   gl->matrix_mode (GLITZ_GL_PROJECTION);
@@ -148,3 +309,22 @@ glitz_clamp_value (glitz_float_t *value,
   else if (*value > max)
     *value = max;
 }
+
+void
+glitz_initiate_state (glitz_gl_proc_address_list_t *gl)
+{
+  gl->disable (GLITZ_GL_DEPTH_TEST); 
+  gl->hint (GLITZ_GL_PERSPECTIVE_CORRECTION_HINT, GLITZ_GL_FASTEST);
+  gl->disable (GLITZ_GL_CULL_FACE);
+  gl->depth_mask (GLITZ_GL_FALSE);  
+  gl->polygon_mode (GLITZ_GL_FRONT_AND_BACK, GLITZ_GL_FILL);
+  gl->disable (GLITZ_GL_POLYGON_SMOOTH);
+  gl->disable (GLITZ_GL_LINE_SMOOTH);
+  gl->disable (GLITZ_GL_POINT_SMOOTH);
+  gl->shade_model (GLITZ_GL_FLAT);
+  gl->color_mask (GLITZ_GL_TRUE, GLITZ_GL_TRUE, GLITZ_GL_TRUE, GLITZ_GL_TRUE);
+  gl->enable (GLITZ_GL_SCISSOR_TEST);
+  gl->disable (GLITZ_GL_STENCIL_TEST);
+  gl->enable_client_state (GLITZ_GL_VERTEX_ARRAY);
+  gl->disable (GLITZ_GL_DEPTH_TEST); 
+}
diff --git a/src/glitzint.h b/src/glitzint.h
index 6c177e5..af47e2c 100644
--- a/src/glitzint.h
+++ b/src/glitzint.h
@@ -67,88 +67,95 @@
 #define GLITZ_STATUS_NOT_SUPPORTED_MASK      (1L << 2)
 #define GLITZ_STATUS_CONTENT_DESTROYED_MASK  (1L << 3)
 
-#define GLITZ_FORMAT_ALL_EXCEPT_ID_MASK ((1L << 19) - 2)
+#define GLITZ_DRAWABLE_FORMAT_ALL_EXCEPT_ID_MASK ((1L << 11) - 2)
 
 #include "glitz_gl.h"
 
+#define GLITZ_DEFAULT_PBUFFER_WIDTH  512
+#define GLITZ_DEFAULT_PBUFFER_HEIGHT 512
+
 #define GLITZ_CONTEXT_STACK_SIZE 16
 
+typedef void (*glitz_function_pointer_t) (void);
+
 typedef struct _glitz_gl_proc_address_list_t {
-  glitz_gl_enable_t enable;
-  glitz_gl_disable_t disable;
-  glitz_gl_get_error_t get_error;
-  glitz_gl_enable_client_state_t enable_client_state;
-  glitz_gl_disable_client_state_t disable_client_state;
-  glitz_gl_vertex_pointer_t vertex_pointer;
-  glitz_gl_draw_arrays_t draw_arrays;
-  glitz_gl_tex_env_f_t tex_env_f;
-  glitz_gl_tex_env_fv_t tex_env_fv;
-  glitz_gl_tex_gen_i_t tex_gen_i;
-  glitz_gl_tex_gen_fv_t tex_gen_fv;
-  glitz_gl_color_4us_t color_4us;
-  glitz_gl_color_4f_t color_4f;
-  glitz_gl_scissor_t scissor;
-  glitz_gl_blend_func_t blend_func;
-  glitz_gl_clear_t clear;
-  glitz_gl_clear_color_t clear_color;
-  glitz_gl_clear_stencil_t clear_stencil;
-  glitz_gl_stencil_func_t stencil_func;
-  glitz_gl_stencil_op_t stencil_op;
-  glitz_gl_push_attrib_t push_attrib;
-  glitz_gl_pop_attrib_t pop_attrib;
-  glitz_gl_matrix_mode_t matrix_mode;
-  glitz_gl_push_matrix_t push_matrix;
-  glitz_gl_pop_matrix_t pop_matrix;
-  glitz_gl_load_identity_t load_identity;
-  glitz_gl_load_matrix_f_t load_matrix_f;
-  glitz_gl_depth_range_t depth_range;
-  glitz_gl_viewport_t viewport;
-  glitz_gl_raster_pos_2f_t raster_pos_2f;
-  glitz_gl_bitmap_t bitmap;
-  glitz_gl_read_buffer_t read_buffer;
-  glitz_gl_draw_buffer_t draw_buffer;
-  glitz_gl_copy_pixels_t copy_pixels;
-  glitz_gl_flush_t flush;
-  glitz_gl_finish_t finish;
-  glitz_gl_pixel_store_i_t pixel_store_i;
-  glitz_gl_ortho_t ortho;
-  glitz_gl_scale_f_t scale_f;
-  glitz_gl_translate_f_t translate_f;
-  glitz_gl_hint_t hint;
-  glitz_gl_depth_mask_t depth_mask;
-  glitz_gl_polygon_mode_t polygon_mode;
-  glitz_gl_shade_model_t shade_model;
-  glitz_gl_color_mask_t color_mask;
-  glitz_gl_read_pixels_t read_pixels;
-  glitz_gl_get_tex_image_t get_tex_image;
-  glitz_gl_tex_sub_image_2d_t tex_sub_image_2d;
-  glitz_gl_gen_textures_t gen_textures;
-  glitz_gl_delete_textures_t delete_textures;
-  glitz_gl_bind_texture_t bind_texture;
-  glitz_gl_tex_image_2d_t tex_image_2d;
-  glitz_gl_tex_parameter_i_t tex_parameter_i;
-  glitz_gl_get_tex_level_parameter_iv_t get_tex_level_parameter_iv;
-  glitz_gl_copy_tex_sub_image_2d_t copy_tex_sub_image_2d;
-  glitz_gl_get_integer_v_t get_integer_v;
-
-  glitz_gl_blend_color_t blend_color;
-  glitz_gl_active_texture_t active_texture;
-  glitz_gl_gen_programs_t gen_programs;
-  glitz_gl_delete_programs_t delete_programs;
-  glitz_gl_program_string_t program_string;
-  glitz_gl_bind_program_t bind_program;
-  glitz_gl_program_local_param_4fv_t program_local_param_4fv;
-  glitz_gl_get_program_iv_t get_program_iv;
-  glitz_gl_gen_buffers_t gen_buffers;
-  glitz_gl_delete_buffers_t delete_buffers;
-  glitz_gl_bind_buffer_t bind_buffer;
-  glitz_gl_buffer_data_t buffer_data;
-  glitz_gl_buffer_sub_data_t buffer_sub_data;
-  glitz_gl_get_buffer_sub_data_t get_buffer_sub_data;
-  glitz_gl_map_buffer_t map_buffer;
-  glitz_gl_unmap_buffer_t unmap_buffer;
   
-  glitz_bool_t need_lookup;
+  /* core */
+  glitz_gl_enable_t                     enable;
+  glitz_gl_disable_t                    disable;
+  glitz_gl_get_error_t                  get_error;
+  glitz_gl_get_string_t                 get_string;
+  glitz_gl_enable_client_state_t        enable_client_state;
+  glitz_gl_disable_client_state_t       disable_client_state;
+  glitz_gl_vertex_pointer_t             vertex_pointer;
+  glitz_gl_draw_arrays_t                draw_arrays;
+  glitz_gl_tex_env_f_t                  tex_env_f;
+  glitz_gl_tex_env_fv_t                 tex_env_fv;
+  glitz_gl_tex_gen_i_t                  tex_gen_i;
+  glitz_gl_tex_gen_fv_t                 tex_gen_fv;
+  glitz_gl_color_4us_t                  color_4us;
+  glitz_gl_color_4f_t                   color_4f;
+  glitz_gl_scissor_t                    scissor;
+  glitz_gl_blend_func_t                 blend_func;
+  glitz_gl_clear_t                      clear;
+  glitz_gl_clear_color_t                clear_color;
+  glitz_gl_clear_stencil_t              clear_stencil;
+  glitz_gl_stencil_func_t               stencil_func;
+  glitz_gl_stencil_op_t                 stencil_op;
+  glitz_gl_push_attrib_t                push_attrib;
+  glitz_gl_pop_attrib_t                 pop_attrib;
+  glitz_gl_matrix_mode_t                matrix_mode;
+  glitz_gl_push_matrix_t                push_matrix;
+  glitz_gl_pop_matrix_t                 pop_matrix;
+  glitz_gl_load_identity_t              load_identity;
+  glitz_gl_load_matrix_f_t              load_matrix_f;
+  glitz_gl_depth_range_t                depth_range;
+  glitz_gl_viewport_t                   viewport;
+  glitz_gl_raster_pos_2f_t              raster_pos_2f;
+  glitz_gl_bitmap_t                     bitmap;
+  glitz_gl_read_buffer_t                read_buffer;
+  glitz_gl_draw_buffer_t                draw_buffer;
+  glitz_gl_copy_pixels_t                copy_pixels;
+  glitz_gl_flush_t                      flush;
+  glitz_gl_finish_t                     finish;
+  glitz_gl_pixel_store_i_t              pixel_store_i;
+  glitz_gl_ortho_t                      ortho;
+  glitz_gl_scale_f_t                    scale_f;
+  glitz_gl_translate_f_t                translate_f;
+  glitz_gl_hint_t                       hint;
+  glitz_gl_depth_mask_t                 depth_mask;
+  glitz_gl_polygon_mode_t               polygon_mode;
+  glitz_gl_shade_model_t                shade_model;
+  glitz_gl_color_mask_t                 color_mask;
+  glitz_gl_read_pixels_t                read_pixels;
+  glitz_gl_get_tex_image_t              get_tex_image;
+  glitz_gl_tex_sub_image_2d_t           tex_sub_image_2d;
+  glitz_gl_gen_textures_t               gen_textures;
+  glitz_gl_delete_textures_t            delete_textures;
+  glitz_gl_bind_texture_t               bind_texture;
+  glitz_gl_tex_image_2d_t               tex_image_2d;
+  glitz_gl_tex_parameter_i_t            tex_parameter_i;
+  glitz_gl_get_tex_level_parameter_iv_t get_tex_level_parameter_iv;
+  glitz_gl_copy_tex_sub_image_2d_t      copy_tex_sub_image_2d;
+  glitz_gl_get_integer_v_t              get_integer_v;
+
+  /* extensions */
+  glitz_gl_blend_color_t                blend_color;
+  glitz_gl_active_texture_t             active_texture;
+  glitz_gl_gen_programs_t               gen_programs;
+  glitz_gl_delete_programs_t            delete_programs;
+  glitz_gl_program_string_t             program_string;
+  glitz_gl_bind_program_t               bind_program;
+  glitz_gl_program_local_param_4fv_t    program_local_param_4fv;
+  glitz_gl_get_program_iv_t             get_program_iv;
+  glitz_gl_gen_buffers_t                gen_buffers;
+  glitz_gl_delete_buffers_t             delete_buffers;
+  glitz_gl_bind_buffer_t                bind_buffer;
+  glitz_gl_buffer_data_t                buffer_data;
+  glitz_gl_buffer_sub_data_t            buffer_sub_data;
+  glitz_gl_get_buffer_sub_data_t        get_buffer_sub_data;
+  glitz_gl_map_buffer_t                 map_buffer;
+  glitz_gl_unmap_buffer_t               unmap_buffer;
 } glitz_gl_proc_address_list_t;
 
 typedef int glitz_surface_type_t;
@@ -164,8 +171,7 @@ typedef int glitz_surface_type_t;
 
 typedef int glitz_combine_type_t;
 
-#define GLITZ_COMBINE_TYPE_NA            -1
-#define GLITZ_COMBINE_TYPE_INTERMEDIATE   0
+#define GLITZ_COMBINE_TYPE_NA             0
 #define GLITZ_COMBINE_TYPE_ARGB           1
 #define GLITZ_COMBINE_TYPE_ARGB_ARGB      2
 #define GLITZ_COMBINE_TYPE_ARGB_ARGBC     3
@@ -201,7 +207,7 @@ typedef int glitz_combine_type_t;
 
 typedef struct _glitz_program_t {
   glitz_gl_int_t *name;
-  unsigned int size;
+  unsigned int   size;
 } glitz_program_t;
 
 typedef struct _glitz_filter_map_t {
@@ -213,15 +219,133 @@ typedef struct _glitz_program_map_t {
 } glitz_program_map_t;
 
 typedef enum {
-  GLITZ_CN_NONE,
-  GLITZ_CN_ANY_CONTEXT_CURRENT,
-  GLITZ_CN_SURFACE_CONTEXT_CURRENT,
-  GLITZ_CN_SURFACE_DRAWABLE_CURRENT
+  GLITZ_NONE,
+  GLITZ_ANY_CONTEXT_CURRENT,
+  GLITZ_CONTEXT_CURRENT,
+  GLITZ_DRAWABLE_CURRENT
 } glitz_constraint_t;
 
-typedef struct _glitz_bounding_box_t {
-  int x1, x2, y1, y2;
-} glitz_bounding_box_t;
+typedef struct _glitz_box_t {
+  short x1, y1, x2, y2;
+} glitz_box_t;
+
+typedef struct _glitz_region_t {
+  glitz_box_t extents;
+  glitz_box_t *box;
+  int         n_box;
+  void        *data;
+  int         size;
+} glitz_region_t;
+
+#define NULL_BOX ((glitz_box_t *) 0)
+
+#define REGION_INIT(region, __box) \
+  { \
+    if (__box) { \
+      (region)->extents = *(__box); \
+      (region)->box = &(region)->extents; \
+      (region)->n_box = 1; \
+    } else { \
+      (region)->extents.x1 = 0; \
+      (region)->extents.y1 = 0; \
+      (region)->extents.x2 = 0; \
+      (region)->extents.y2 = 0; \
+      (region)->box = NULL; \
+      (region)->n_box = 0; \
+    } \
+  }
+
+#define REGION_EMPTY(region) \
+  { \
+    (region)->extents.x1 = 0; \
+    (region)->extents.y1 = 0; \
+    (region)->extents.x2 = 0; \
+    (region)->extents.y2 = 0; \
+    (region)->box = NULL; \
+    (region)->n_box = 0; \
+  }
+
+#define REGION_UNINIT(region) \
+  { \
+    REGION_EMPTY (region); \
+    if ((region)->data) \
+      free ((region)->data); \
+    (region)->data = NULL; \
+    (region)->size = 0; \
+  }
+
+#define REGION_NOTEMPTY(region) \
+  ((region)->n_box)
+
+#define REGION_RECTS(region) \
+  ((region)->box)
+
+#define REGION_NUM_RECTS(region) \
+  ((region)->n_box)
+
+#define REGION_EXTENTS(region) \
+ (&(region)->extents)
+
+#define REGION_UNION(region, box) \
+  glitz_region_union (region, box)
+
+extern glitz_status_t __internal_linkage
+glitz_region_union (glitz_region_t *region,
+                    glitz_box_t    *box);
+
+typedef struct glitz_backend {
+  glitz_drawable_t *
+  (*create_pbuffer)            (void                       *drawable,
+                                glitz_drawable_format_t    *format,
+                                glitz_pbuffer_attributes_t *attributes,
+                                unsigned long              mask);
+  
+  void
+  (*destroy)                   (void *drawable);
+
+  void
+  (*push_current)              (void               *drawable,
+                                glitz_surface_t    *surface,
+                                glitz_constraint_t constraint);
+
+  glitz_surface_t *
+  (*pop_current)               (void *drawable);
+
+  void
+  (*swap_buffers)              (void *drawable);
+
+  glitz_status_t
+  (*make_current_read)         (void *drawable);
+
+  glitz_gl_proc_address_list_t gl;
+  
+  glitz_drawable_format_t      *drawable_formats;
+  int                          n_drawable_formats;
+
+  glitz_gl_int_t               *texture_formats;
+  glitz_format_t               *formats;
+  int                          n_formats;
+
+  glitz_gl_float_t             gl_version;
+  glitz_gl_int_t               max_texture_2d_size;
+  glitz_gl_int_t               max_texture_rect_size;
+  unsigned long                feature_mask;
+  
+  glitz_program_map_t          *program_map;
+} glitz_backend_t;
+
+struct _glitz_drawable {
+  glitz_backend_t         *backend;
+
+  int                     ref_count;
+  glitz_drawable_format_t *format;
+  int                     width, height;
+  glitz_rectangle_t       viewport;
+  glitz_bool_t            update_all;
+};
+
+#define GLITZ_GL_DRAWABLE(drawable) \
+  glitz_gl_proc_address_list_t *gl = &(drawable)->backend->gl;
 
 typedef struct _glitz_point_t {
   glitz_float_t x, y;
@@ -251,96 +375,56 @@ typedef struct _glitz_vec_t {
 typedef struct _glitz_texture {
   glitz_gl_uint_t name;
   glitz_gl_enum_t target;
-  glitz_gl_enum_t format;
-  unsigned long flags;
+  glitz_gl_int_t  format;
+  unsigned long   flags;
   
   glitz_gl_enum_t filter;
   glitz_gl_enum_t wrap;
   
-  unsigned int width;
-  unsigned int height;
+  int             width;
+  int             height;
 
-  glitz_bounding_box_t box;
+  glitz_box_t     box;
   
-  glitz_float_t texcoord_width_unit;
-  glitz_float_t texcoord_height_unit;
+  glitz_float_t   texcoord_width_unit;
+  glitz_float_t   texcoord_height_unit;
 } glitz_texture_t;
 
 struct _glitz_buffer {
-  glitz_gl_uint_t name;
-  glitz_gl_enum_t target;
-  void *data;
-  int owns_data;
-  int ref_count;
-  glitz_surface_t *surface;
+  glitz_gl_uint_t  name;
+  glitz_gl_enum_t  target;
+  void             *data;
+  int              owns_data;
+  int              ref_count;
+  glitz_drawable_t *drawable;
 };
 
 typedef struct _glitz_geometry {
-  glitz_gl_enum_t primitive;
-  glitz_gl_enum_t type;
-  glitz_gl_int_t first;
+  glitz_gl_enum_t  primitive;
+  glitz_gl_enum_t  type;
+  glitz_gl_int_t   first;
   glitz_gl_sizei_t count;
-  glitz_buffer_t *buffer;
-  glitz_float_t x_offset;
-  glitz_float_t y_offset;
+  glitz_buffer_t   *buffer;
+  glitz_float_t    x_offset;
+  glitz_float_t    y_offset;
   glitz_gl_float_t data[8];
 } glitz_geometry_t;
 
-typedef struct glitz_surface_backend {
-  glitz_surface_t *
-  (*create_similar) (void *surface,
-                     glitz_format_t *format,
-                     int width,
-                     int height);
-  
-  void
-  (*destroy) (void *surface);
-  
-  glitz_bool_t
-  (*push_current) (void *surface,
-                   glitz_constraint_t constraint);
-
-  void
-  (*pop_current) (void *surface);
-
-  glitz_texture_t *
-  (*get_texture) (void *surface,
-                  glitz_bool_t allocate);
-  
-  void
-  (*swap_buffers) (void *surface);
-
-  glitz_bool_t
-  (*make_current_read) (void *surface);
-
-  glitz_gl_proc_address_list_t gl;
-  glitz_format_t *formats;
-  int n_formats;
-  glitz_program_map_t *program_map;
-  unsigned long feature_mask;
-} glitz_surface_backend_t;
-
 #define GLITZ_SURFACE_FLAG_SOLID_MASK                   (1L <<  0)
-#define GLITZ_SURFACE_FLAG_OFFSCREEN_MASK               (1L <<  1)
-#define GLITZ_SURFACE_FLAG_REPEAT_MASK                  (1L <<  2)
-#define GLITZ_SURFACE_FLAG_MIRRORED_MASK                (1L <<  3)
-#define GLITZ_SURFACE_FLAG_PAD_MASK                     (1L <<  4)
-#define GLITZ_SURFACE_FLAG_DIRTY_MASK                   (1L <<  5)
-#define GLITZ_SURFACE_FLAG_COMPONENT_ALPHA_MASK         (1L <<  6)
-#define GLITZ_SURFACE_FLAG_MULTISAMPLE_MASK             (1L <<  7)
-#define GLITZ_SURFACE_FLAG_NICEST_MULTISAMPLE_MASK      (1L <<  8)
-#define GLITZ_SURFACE_FLAG_SOLID_DIRTY_MASK             (1L <<  9)
-#define GLITZ_SURFACE_FLAG_DRAWABLE_DIRTY_MASK          (1L << 10)
-#define GLITZ_SURFACE_FLAG_FRAGMENT_FILTER_MASK         (1L << 11)
-#define GLITZ_SURFACE_FLAG_LINEAR_TRANSFORM_FILTER_MASK (1L << 12)
-#define GLITZ_SURFACE_FLAG_DRAWABLE_MASK                (1L << 13)
-#define GLITZ_SURFACE_FLAG_IGNORE_WRAP_MASK             (1L << 14)
-#define GLITZ_SURFACE_FLAG_EYE_COORDS_MASK              (1L << 15)
-#define GLITZ_SURFACE_FLAG_TRANSFORM_MASK               (1L << 16)
-#define GLITZ_SURFACE_FLAG_PROJECTIVE_TRANSFORM_MASK    (1L << 17)
-
-#define SURFACE_OFFSCREEN(surface) \
-  ((surface)->flags & GLITZ_SURFACE_FLAG_OFFSCREEN_MASK)
+#define GLITZ_SURFACE_FLAG_REPEAT_MASK                  (1L <<  1)
+#define GLITZ_SURFACE_FLAG_MIRRORED_MASK                (1L <<  2)
+#define GLITZ_SURFACE_FLAG_PAD_MASK                     (1L <<  3)
+#define GLITZ_SURFACE_FLAG_COMPONENT_ALPHA_MASK         (1L <<  4)
+#define GLITZ_SURFACE_FLAG_DITHER_MASK                  (1L <<  5)
+#define GLITZ_SURFACE_FLAG_MULTISAMPLE_MASK             (1L <<  6)
+#define GLITZ_SURFACE_FLAG_NICEST_MULTISAMPLE_MASK      (1L <<  7)
+#define GLITZ_SURFACE_FLAG_SOLID_DAMAGE_MASK            (1L <<  8)
+#define GLITZ_SURFACE_FLAG_FRAGMENT_FILTER_MASK         (1L <<  9)
+#define GLITZ_SURFACE_FLAG_LINEAR_TRANSFORM_FILTER_MASK (1L << 10)
+#define GLITZ_SURFACE_FLAG_IGNORE_WRAP_MASK             (1L << 11)
+#define GLITZ_SURFACE_FLAG_EYE_COORDS_MASK              (1L << 12)
+#define GLITZ_SURFACE_FLAG_TRANSFORM_MASK               (1L << 13)
+#define GLITZ_SURFACE_FLAG_PROJECTIVE_TRANSFORM_MASK    (1L << 14)
 
 #define SURFACE_SOLID(surface) \
   ((surface)->flags & GLITZ_SURFACE_FLAG_SOLID_MASK)
@@ -356,23 +440,20 @@ typedef struct glitz_surface_backend {
   (((surface)->flags & GLITZ_SURFACE_FLAG_PAD_MASK) && \
    (!((surface)->flags & GLITZ_SURFACE_FLAG_IGNORE_WRAP_MASK)))
 
-#define SURFACE_DIRTY(surface) \
-  ((surface)->flags & GLITZ_SURFACE_FLAG_DIRTY_MASK)
-
 #define SURFACE_COMPONENT_ALPHA(surface) \
   ((surface)->flags & GLITZ_SURFACE_FLAG_COMPONENT_ALPHA_MASK)
 
+#define SURFACE_DITHER(surface) \
+  ((surface)->flags & GLITZ_SURFACE_FLAG_DITHER_MASK)
+
 #define SURFACE_MULTISAMPLE(surface) \
   ((surface)->flags & GLITZ_SURFACE_FLAG_MULTISAMPLE_MASK)
 
 #define SURFACE_NICEST_MULTISAMPLE(surface) \
   ((surface)->flags & GLITZ_SURFACE_FLAG_NICEST_MULTISAMPLE_MASK)
 
-#define SURFACE_SOLID_DIRTY(surface) \
-  ((surface)->flags & GLITZ_SURFACE_FLAG_SOLID_DIRTY_MASK)
-
-#define SURFACE_DRAWABLE_DIRTY(surface) \
-  ((surface)->flags & GLITZ_SURFACE_FLAG_DRAWABLE_DIRTY_MASK)
+#define SURFACE_SOLID_DAMAGE(surface) \
+  ((surface)->flags & GLITZ_SURFACE_FLAG_SOLID_DAMAGE_MASK)
 
 #define SURFACE_FRAGMENT_FILTER(surface) \
   ((surface)->flags & GLITZ_SURFACE_FLAG_FRAGMENT_FILTER_MASK)
@@ -380,9 +461,6 @@ typedef struct glitz_surface_backend {
 #define SURFACE_LINEAR_TRANSFORM_FILTER(surface) \
   ((surface)->flags & GLITZ_SURFACE_FLAG_LINEAR_TRANSFORM_FILTER_MASK)
 
-#define SURFACE_DRAWABLE(surface) \
-  ((surface)->flags & GLITZ_SURFACE_FLAG_DRAWABLE_MASK)
-
 #define SURFACE_EYE_COORDS(surface) \
   ((surface)->flags & GLITZ_SURFACE_FLAG_EYE_COORDS_MASK)
 
@@ -399,8 +477,8 @@ typedef struct _glitz_sample_offset {
 
 typedef struct _glitz_multi_sample_info {
   glitz_sample_offset_t *offsets;
-  unsigned short *weights;
-  int n_samples;
+  unsigned short        *weights;
+  int                   n_samples;
 } glitz_sample_info_t;
 
 typedef struct _glitz_filter_params_t glitz_filter_params_t;
@@ -410,186 +488,194 @@ typedef struct _glitz_matrix {
   glitz_float_t m[16];
 } glitz_matrix_t;
 
-#define GLITZ_UPDATE_VIEWPORT_MASK    (1L << 0)
-#define GLITZ_UPDATE_DRAW_BUFFER_MASK (1L << 1)
-#define GLITZ_UPDATE_MULTISAMPLE_MASK (1L << 2)
-#define GLITZ_UPDATE_ALL_MASK         ((1L << 3) - 1)
+#define GLITZ_DAMAGE_TEXTURE_MASK  (1 << 0)
+#define GLITZ_DAMAGE_DRAWABLE_MASK (1 << 1)
+#define GLITZ_DAMAGE_SOLID_MASK    (1 << 2)
 
 struct _glitz_surface {
-  glitz_surface_backend_t *backend;
-
-  int ref_count;
-  glitz_format_t *format;
-  glitz_texture_t texture;
-  unsigned long status_mask;
-  unsigned long update_mask;
-  glitz_filter_t filter;
+  int                   ref_count;
+  glitz_format_t        *format;
+  glitz_texture_t       texture;
+  glitz_drawable_t      *drawable;
+  glitz_drawable_t      *attached;
+  unsigned long         status_mask;
+  glitz_filter_t        filter;
   glitz_filter_params_t *filter_params;
-  glitz_matrix_t *transform;
-  int width, height;
-  glitz_bounding_box_t dirty_box;
-  unsigned long flags;
-  glitz_gl_enum_t draw_buffer;
-  glitz_gl_enum_t read_buffer;
-  glitz_sample_info_t *indirect;
-  glitz_color_t solid;
-  glitz_geometry_t geometry;
+  glitz_matrix_t        *transform;
+  int                   x, y;
+  int                   width, height;
+  glitz_gl_enum_t       buffer;
+  unsigned long         flags;
+  glitz_sample_info_t   *indirect;
+  glitz_color_t         solid;
+  glitz_geometry_t      geometry;
+  glitz_region_t        texture_damage;
+  glitz_region_t        drawable_damage;
 };
 
+#define GLITZ_GL_SURFACE(surface) \
+  glitz_gl_proc_address_list_t *gl = &(surface)->drawable->backend->gl;
+
 typedef struct _glitz_composite_op_t glitz_composite_op_t;
 
 typedef void (*glitz_combine_function_t) (glitz_composite_op_t *);
 
 typedef struct _glitz_combine_t {
-  glitz_combine_type_t type;
+  glitz_combine_type_t     type;
   glitz_combine_function_t enable;
-  int texture_units;
-  int fragment_processing;
+  int                      texture_units;
+  int                      fragment_processing;
 } glitz_combine_t;
 
 struct _glitz_composite_op_t {
-  glitz_combine_type_t type;
-  glitz_combine_t *combine;
+  glitz_combine_type_t         type;
+  glitz_combine_t              *combine;
   glitz_gl_proc_address_list_t *gl;
-  glitz_operator_t render_op;
-  glitz_surface_t *src;
-  glitz_surface_t *mask;
-  glitz_surface_t *dst;
-  glitz_color_t *solid;
-  glitz_color_t alpha_mask;
-  int per_component;
-  glitz_gl_uint_t fp;
-  int count;
+  glitz_operator_t             render_op;
+  glitz_surface_t              *src;
+  glitz_surface_t              *mask;
+  glitz_surface_t              *dst;
+  glitz_color_t                *solid;
+  glitz_color_t                alpha_mask;
+  int                          per_component;
+  glitz_gl_uint_t              fp;
+  int                          count;
 };
 
 typedef struct _glitz_extension_map {
   glitz_gl_float_t version;
-  char *name;
-  int mask;
+  char             *name;
+  int              mask;
 } glitz_extension_map;
 
 extern void __internal_linkage
-glitz_set_operator (glitz_gl_proc_address_list_t *gl, glitz_operator_t op);
-
-void
-glitz_intersect_bounding_box (glitz_bounding_box_t *box1,
-                              glitz_bounding_box_t *box2,
-                              glitz_bounding_box_t *return_box);
-
-extern void __internal_linkage
-glitz_union_bounding_box (glitz_bounding_box_t *box1,
-                          glitz_bounding_box_t *box2,
-                          glitz_bounding_box_t *return_box);
+glitz_set_operator (glitz_gl_proc_address_list_t *gl,
+                    glitz_operator_t             op);
 
 unsigned long
-glitz_extensions_query (glitz_gl_float_t version,
-                        const char *extensions_string,
+glitz_extensions_query (glitz_gl_float_t    version,
+                        const char          *extensions_string,
                         glitz_extension_map *extensions_map);
 
+typedef glitz_function_pointer_t (* glitz_get_proc_address_proc_t)
+     (const char *name, void *closure);
+
+void
+glitz_backend_init (glitz_backend_t               *backend,
+                    glitz_get_proc_address_proc_t get_proc_address,
+                    void                          *closure);
+
 extern unsigned int __internal_linkage
 glitz_uint_to_power_of_two (unsigned int x);
 
 extern void __internal_linkage
 glitz_set_raster_pos (glitz_gl_proc_address_list_t *gl,
-                      int x,
-                      int y);
+                      int                          x,
+                      int                          y);
 
 extern void __internal_linkage
 glitz_clamp_value (glitz_float_t *value,
-                   glitz_float_t min, glitz_float_t max);
+                   glitz_float_t min,
+                   glitz_float_t max);
+
+void
+glitz_initiate_state (glitz_gl_proc_address_list_t *gl);
+
+void
+glitz_create_surface_formats (glitz_gl_proc_address_list_t *gl,
+                              glitz_format_t               **formats,
+                              glitz_gl_int_t               **texture_formats,
+                              int                          *n_formats);
+
+glitz_drawable_format_t *
+glitz_drawable_format_find (glitz_drawable_format_t       *formats,
+                            int                           n_formats,
+                            unsigned long                 mask,
+                            const glitz_drawable_format_t *templ,
+                            int                           count);
 
 void
 glitz_texture_init (glitz_texture_t *texture,
-                    unsigned int width,
-                    unsigned int height,
-                    unsigned int texture_format,
-                    unsigned long feature_mask);
+                    int             width,
+                    int             height,
+                    glitz_gl_int_t  texture_format,
+                    unsigned long   feature_mask);
 
 void
 glitz_texture_fini (glitz_gl_proc_address_list_t *gl,
-                    glitz_texture_t *texture);
+                    glitz_texture_t              *texture);
 
 void
 glitz_texture_size_check (glitz_gl_proc_address_list_t *gl,
-                          glitz_texture_t *texture,
-                          glitz_gl_int_t max_2d,
-                          glitz_gl_int_t max_rect);
+                          glitz_texture_t              *texture,
+                          glitz_gl_int_t               max_2d,
+                          glitz_gl_int_t               max_rect);
 
 void
 glitz_texture_allocate (glitz_gl_proc_address_list_t *gl,
-                        glitz_texture_t *texture);
+                        glitz_texture_t              *texture);
 
 extern void __internal_linkage
 glitz_texture_ensure_filter (glitz_gl_proc_address_list_t *gl,
-                             glitz_texture_t *texture,
-                             glitz_filter_t filter);
+                             glitz_texture_t              *texture,
+                             glitz_filter_t               filter);
 
 extern void __internal_linkage
 glitz_texture_ensure_wrap (glitz_gl_proc_address_list_t *gl,
-                           glitz_texture_t *texture,
-                           glitz_gl_enum_t wrap);
+                           glitz_texture_t              *texture,
+                           glitz_gl_enum_t              wrap);
 
 void
 glitz_texture_bind (glitz_gl_proc_address_list_t *gl,
-                    glitz_texture_t *texture);
+                    glitz_texture_t              *texture);
 
 void
 glitz_texture_unbind (glitz_gl_proc_address_list_t *gl,
-                      glitz_texture_t *texture);
+                      glitz_texture_t              *texture);
 
 void
-glitz_texture_copy_surface (glitz_texture_t *texture,
-                            glitz_surface_t *surface,
-                            int x_surface,
-                            int y_surface,
-                            int width,
-                            int height,
-                            int x_texture,
-                            int y_texture);
+glitz_texture_copy_drawable (glitz_gl_proc_address_list_t *gl,
+                             glitz_texture_t              *texture,
+                             glitz_drawable_t             *drawable,
+                             int                          x_drawable,
+                             int                          y_drawable,
+                             int                          width,
+                             int                          height,
+                             int                          x_texture,
+                             int                          y_texture);
 
 void
 glitz_texture_set_tex_gen (glitz_gl_proc_address_list_t *gl,
-                           glitz_texture_t *texture,
-                           int x_src,
-                           int y_src,
-                           unsigned long flags);
-
-void
-glitz_surface_init (glitz_surface_t *surface,
-                    glitz_surface_backend_t *backend,
-                    glitz_format_t *format,
-                    int width,
-                    int height);
-
-void
-glitz_surface_fini (glitz_surface_t *surface);
+                           glitz_texture_t              *texture,
+                           int                          x_src,
+                           int                          y_src,
+                           unsigned long                flags);
 
 extern glitz_texture_t *__internal_linkage
 glitz_surface_get_texture (glitz_surface_t *surface,
-                           glitz_bool_t allocate);
+                           glitz_bool_t    allocate);
 
 extern void __internal_linkage
-glitz_surface_ensure_solid (glitz_surface_t *surface);
+glitz_surface_sync_solid (glitz_surface_t *surface);
 
-glitz_bool_t
-glitz_surface_push_current (glitz_surface_t *surface,
+extern glitz_bool_t __internal_linkage
+glitz_surface_push_current (glitz_surface_t    *surface,
                             glitz_constraint_t constraint);
 
-void
+extern void __internal_linkage
 glitz_surface_pop_current (glitz_surface_t *surface);
 
-extern glitz_bool_t __internal_linkage
+extern glitz_status_t __internal_linkage
 glitz_surface_make_current_read (glitz_surface_t *surface);
 
 extern void __internal_linkage
-glitz_surface_dirty (glitz_surface_t *surface,
-                     glitz_bounding_box_t *box);
+glitz_surface_damage (glitz_surface_t *surface,
+                      glitz_box_t     *box,
+                      int             what);
 
 extern void __internal_linkage
-glitz_surface_status_add (glitz_surface_t *surface, int flags);
-
-void
-glitz_surface_update_state (glitz_surface_t *surface);
+glitz_surface_status_add (glitz_surface_t *surface,
+                          int             flags);
 
 extern unsigned long __internal_linkage
 glitz_status_to_status_mask (glitz_status_t status);
@@ -597,48 +683,24 @@ glitz_status_to_status_mask (glitz_status_t status);
 extern glitz_status_t __internal_linkage
 glitz_status_pop_from_mask (unsigned long *mask);
 
-typedef void (*glitz_format_call_back_t) (glitz_format_t *, void *ptr);
-
-void
-glitz_format_for_each_texture_format (glitz_format_call_back_t call_back,
-                                      glitz_gl_proc_address_list_t *gl,
-                                      void *ptr);
-
-glitz_format_t *
-glitz_format_find (glitz_format_t *formats,
-                   int n_formats,
-                   unsigned long mask,
-                   const glitz_format_t *templ,
-                   int count);
-
-glitz_format_t *
-glitz_format_find_standard (glitz_format_t *formats,
-                            int n_formats,
-                            glitz_format_name_t format_name);
-
-extern glitz_gl_int_t __internal_linkage
-glitz_format_get_best_texture_format (glitz_format_t *formats,
-                                      int n_formats,
-                                      glitz_format_t *format);
-
 void
 glitz_program_map_init (glitz_program_map_t *map);
      
 void
 glitz_program_map_fini (glitz_gl_proc_address_list_t *gl,
-                        glitz_program_map_t *map);
+                        glitz_program_map_t          *map);
 
 extern glitz_gl_uint_t __internal_linkage
 glitz_get_fragment_program (glitz_composite_op_t *op,
-                            int fp_type,
-                            int id);
+                            int                  fp_type,
+                            int                  id);
 
 extern void __internal_linkage
 glitz_composite_op_init (glitz_composite_op_t *op,
-                         glitz_operator_t render_op,
-                         glitz_surface_t *src,
-                         glitz_surface_t *mask,
-                         glitz_surface_t *dst);
+                         glitz_operator_t     render_op,
+                         glitz_surface_t      *src,
+                         glitz_surface_t      *mask,
+                         glitz_surface_t      *dst);
 
 extern void __internal_linkage
 glitz_composite_enable (glitz_composite_op_t *op);
@@ -647,53 +709,54 @@ extern void __internal_linkage
 glitz_composite_disable (glitz_composite_op_t *op);
 
 extern void *__internal_linkage
-glitz_buffer_bind (glitz_buffer_t *buffer,
+glitz_buffer_bind (glitz_buffer_t  *buffer,
                    glitz_gl_enum_t target);
 
 extern void __internal_linkage
 glitz_buffer_unbind (glitz_buffer_t *buffer);
 
 extern glitz_status_t __internal_linkage
-glitz_filter_set_params (glitz_surface_t *surface,
-                         glitz_filter_t filter,
+glitz_filter_set_params (glitz_surface_t    *surface,
+                         glitz_filter_t     filter,
                          glitz_fixed16_16_t *params,
-                         int n_params);
+                         int                n_params);
 
 extern void __internal_linkage
 glitz_filter_set_type (glitz_surface_t *surface,
-                       glitz_filter_t filter);
+                       glitz_filter_t  filter);
 
 extern void __internal_linkage
 glitz_filter_params_destroy (glitz_filter_params_t *params);
 
 extern glitz_gl_uint_t __internal_linkage
-glitz_filter_get_vertex_program (glitz_surface_t *surface,
+glitz_filter_get_vertex_program (glitz_surface_t      *surface,
                                  glitz_composite_op_t *op);
 
 extern glitz_gl_uint_t __internal_linkage
-glitz_filter_get_fragment_program (glitz_surface_t *surface,
+glitz_filter_get_fragment_program (glitz_surface_t      *surface,
                                    glitz_composite_op_t *op);
 
 extern void __internal_linkage
-glitz_filter_enable (glitz_surface_t *surface,
+glitz_filter_enable (glitz_surface_t      *surface,
                      glitz_composite_op_t *op);
 
 extern void __internal_linkage
 glitz_geometry_enable_default (glitz_gl_proc_address_list_t *gl,
-                               glitz_surface_t *dst,
-                               glitz_bounding_box_t *box);
+                               glitz_surface_t              *dst,
+                               glitz_box_t                  *box);
 
 extern void __internal_linkage
 glitz_geometry_enable (glitz_gl_proc_address_list_t *gl,
-                       glitz_surface_t *dst,
-                       glitz_gl_enum_t *primitive,
-                       glitz_gl_int_t *first,
-                       glitz_gl_sizei_t *count,
-                       glitz_bounding_box_t *box);
+                       glitz_surface_t              *dst,
+                       glitz_gl_enum_t              *primitive,
+                       glitz_gl_int_t               *first,
+                       glitz_gl_sizei_t             *count,
+                       glitz_box_t                  *box);
 
 extern void __internal_linkage
 glitz_geometry_disable (glitz_gl_proc_address_list_t *gl,
-                        glitz_surface_t *dst);
+                        glitz_surface_t              *dst);
+
 
 #define MAXSHORT SHRT_MAX
 #define MINSHORT SHRT_MIN
@@ -768,26 +831,31 @@ typedef glitz_fixed_16_16 glitz_fixed;
 
 #define POWER_OF_TWO(v) ((v & (v - 1)) == 0)
 
-typedef void (*glitz_function_pointer_t) (void);
-
 
 /* Avoid unnecessary PLT entries.  */
 
-slim_hidden_proto(glitz_surface_find_similar_standard_format)
+slim_hidden_proto(glitz_find_similar_drawable_format)
+slim_hidden_proto(glitz_create_pbuffer_drawable)
+slim_hidden_proto(glitz_drawable_get_width)
+slim_hidden_proto(glitz_drawable_get_height)
+slim_hidden_proto(glitz_drawable_swap_buffers)
+slim_hidden_proto(glitz_drawable_swap_buffers)
+slim_hidden_proto(glitz_drawable_flush)
+slim_hidden_proto(glitz_drawable_finish)
+slim_hidden_proto(glitz_drawable_get_features)
+slim_hidden_proto(glitz_drawable_get_format)
 slim_hidden_proto(glitz_surface_set_transform)
 slim_hidden_proto(glitz_surface_set_fill)
 slim_hidden_proto(glitz_surface_set_component_alpha)
+slim_hidden_proto(glitz_surface_set_dither)
 slim_hidden_proto(glitz_surface_set_filter)
 slim_hidden_proto(glitz_surface_get_width)
 slim_hidden_proto(glitz_surface_get_height)
-slim_hidden_proto(glitz_surface_set_read_color_buffer)
-slim_hidden_proto(glitz_surface_set_draw_color_buffer)
 slim_hidden_proto(glitz_surface_flush)
-slim_hidden_proto(glitz_surface_swap_buffers)
-slim_hidden_proto(glitz_surface_finish)
 slim_hidden_proto(glitz_surface_get_status)
-slim_hidden_proto(glitz_surface_get_features)
 slim_hidden_proto(glitz_surface_get_format)
+slim_hidden_proto(glitz_surface_get_drawable)
+slim_hidden_proto(glitz_surface_get_attached_drawable)
 slim_hidden_proto(glitz_set_rectangle)
 slim_hidden_proto(glitz_set_rectangles)
 slim_hidden_proto(glitz_set_geometry)
diff --git a/src/glx/Makefile.am b/src/glx/Makefile.am
new file mode 100644
index 0000000..0fffbc0
--- /dev/null
+++ b/src/glx/Makefile.am
@@ -0,0 +1,40 @@
+if GLITZ_BUILD_GLX_BACKEND
+
+INCLUDES =	      \
+	$(GLITZ_INC)  \
+	$(GLX_CFLAGS)
+
+lib_LTLIBRARIES = libglitz-glx.la
+include_HEADERS = glitz-glx.h
+
+libglitz_glx_la_SOURCES =     \
+	glitz-glx.h	      \
+	glitz_glx_drawable.c  \
+	glitz_glx_format.c    \
+	glitz_glx_info.c      \
+	glitz_glx_extension.c \
+	glitz_glx_context.c   \
+	glitz_glx_pbuffer.c   \
+	glitz_glxext.h	      \
+	glitz_glxint.h
+
+libglitz_glx_la_LDFLAGS = -version-info @VERSION_INFO@ -no-undefined
+libglitz_glx_la_LIBADD = $(GLITZ_LIB) $(GLX_LIBS)
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = glitz-glx.pc
+
+endif
+
+EXTRA_DIST =		      \
+	glitz-glx.h	      \
+	glitz_glx_drawable.c  \
+	glitz_glx_format.c    \
+	glitz_glx_info.c      \
+	glitz_glx_extension.c \
+	glitz_glx_context.c   \
+	glitz_glx_pbuffer.c   \
+	glitz_glxext.h	      \
+	glitz_glxint.h	      \
+	glitz-glx.pc.in	      \
+	glitz-glx.man
diff --git a/src/glx/glitz-glx.h b/src/glx/glitz-glx.h
new file mode 100644
index 0000000..818906c
--- /dev/null
+++ b/src/glx/glitz-glx.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifndef GLITZ_GLX_H_INCLUDED
+#define GLITZ_GLX_H_INCLUDED
+
+#include <glitz.h>
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+/* glitz_glx_info.c */
+
+void
+glitz_glx_init (const char *gl_library);
+
+void
+glitz_glx_fini (void);
+  
+  
+/* glitz_glx_format.c */
+
+glitz_drawable_format_t *
+glitz_glx_find_drawable_format (Display                       *display,
+                                int                           screen,
+                                unsigned long                 mask,
+                                const glitz_drawable_format_t *templ,
+                                int                           count);
+  
+XVisualInfo *
+glitz_glx_get_visual_info_from_format (Display                 *display,
+                                       int                     screen,
+                                       glitz_drawable_format_t *format);
+  
+
+/* glitz_glx_drawable.c */
+
+glitz_drawable_t *
+glitz_glx_create_drawable_for_window (Display                 *display,
+                                      int                     screen,
+                                      glitz_drawable_format_t *format,
+                                      Window                  window,
+                                      int                     width,
+                                      int                     height);
+
+glitz_drawable_t *
+glitz_glx_create_pbuffer_drawable (Display                    *display,
+                                   int                        screen,
+                                   glitz_drawable_format_t    *format,
+                                   glitz_pbuffer_attributes_t *attributes,
+                                   unsigned long              mask);
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif /* GLITZ_GLX_H_INCLUDED */
diff --git a/src/glx/glitz-glx.man b/src/glx/glitz-glx.man
new file mode 100644
index 0000000..4ad99ae
--- /dev/null
+++ b/src/glx/glitz-glx.man
@@ -0,0 +1,26 @@
+.\"
+.\"
+.de TQ
+.br
+.ns
+.TP
+\\$1
+..
+.TH GLITZ-GLX 3 "Version 1.0"
+
+.SH NAME
+GLITZ-GLX \- GLX interface to glitz
+
+.SH SYNOPSIS
+.nf
+.B #include <glitz-glx.h>
+.fi
+.SH DESCRIPTION
+
+GLX interface to glitz.
+
+.SH AUTHOR
+David Reveman
+
+.SH "SEE ALSO"
+.BR GLITZ (3)
\ No newline at end of file
diff --git a/glitz-glx.pc.in b/src/glx/glitz-glx.pc.in
index 2393cb2..2393cb2 100644
--- a/glitz-glx.pc.in
+++ b/src/glx/glitz-glx.pc.in
diff --git a/src/glx/glitz_glx_context.c b/src/glx/glitz_glx_context.c
new file mode 100644
index 0000000..b251ee2
--- /dev/null
+++ b/src/glx/glitz_glx_context.c
@@ -0,0 +1,291 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_glxint.h"
+
+#include <stdlib.h>
+
+extern glitz_gl_proc_address_list_t _glitz_glx_gl_proc_address;
+
+static void
+_glitz_glx_context_create (glitz_glx_screen_info_t *screen_info,
+                           XID                     visualid,
+                           GLXContext              share_list,
+                           glitz_glx_context_t     *context)
+{
+  int vis_info_count, i;
+  XVisualInfo *vis_infos;
+
+  vis_infos = XGetVisualInfo (screen_info->display_info->display,
+                              0, NULL, &vis_info_count);
+  for (i = 0; i < vis_info_count; i++) {
+    if (vis_infos[i].visual->visualid == visualid)
+      break;
+  }
+
+  context->context = glXCreateContext (screen_info->display_info->display,
+                                       &vis_infos[i], share_list,
+                                       GLITZ_GL_TRUE);
+  context->id = visualid;  
+  context->fbconfig = (GLXFBConfig) 0;
+
+  XFree (vis_infos);
+}
+
+static void
+_glitz_glx_context_create_using_fbconfig (glitz_glx_screen_info_t *screen_info,
+                                          XID                     fbconfigid,
+                                          GLXContext              share_list,
+                                          glitz_glx_context_t     *context)
+{
+  GLXFBConfig *fbconfigs;
+  int i, n_fbconfigs;
+  XVisualInfo *vinfo = NULL;
+  glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
+
+  fbconfigs = glx->get_fbconfigs (screen_info->display_info->display,
+                                  screen_info->screen, &n_fbconfigs);
+  for (i = 0; i < n_fbconfigs; i++) {
+    int value;
+    
+    glx->get_fbconfig_attrib (screen_info->display_info->display, fbconfigs[i],
+                              GLX_FBCONFIG_ID, &value);
+    if (value == (int) fbconfigid)
+      break;
+  }
+
+  if (i < n_fbconfigs)
+    vinfo = glx->get_visual_from_fbconfig (screen_info->display_info->display,
+                                           fbconfigs[i]);
+
+  context->id = fbconfigid;
+  if (vinfo) {
+    context->context = glXCreateContext (screen_info->display_info->display,
+                                         vinfo, share_list, GLITZ_GL_TRUE);
+    XFree (vinfo);
+  } else if (glx->create_new_context)
+    context->context =
+      glx->create_new_context (screen_info->display_info->display,
+                               fbconfigs[i], GLX_RGBA_TYPE, share_list,
+                               GLITZ_GL_TRUE);
+  
+  if (context->context)
+    context->fbconfig = fbconfigs[i];
+  else
+    context->fbconfig = (GLXFBConfig) 0;
+
+  if (fbconfigs)
+    XFree (fbconfigs);
+}
+
+glitz_glx_context_t *
+glitz_glx_context_get (glitz_glx_screen_info_t *screen_info,
+                       glitz_drawable_format_t *format)
+{
+  glitz_glx_context_t *context;
+  glitz_glx_context_t **contexts = screen_info->contexts;
+  int index, n_contexts = screen_info->n_contexts;
+  XID format_id;
+
+  for (; n_contexts; n_contexts--, contexts++)
+    if ((*contexts)->id == screen_info->format_ids[format->id])
+      return *contexts;
+
+  index = screen_info->n_contexts++;
+
+  screen_info->contexts =
+    realloc (screen_info->contexts,
+             sizeof (glitz_glx_context_t *) * screen_info->n_contexts);
+  if (!screen_info->contexts)
+    return NULL;
+
+  context = malloc (sizeof (glitz_glx_context_t));
+  if (!context)
+    return NULL;
+  
+  screen_info->contexts[index] = context;
+
+  format_id = screen_info->format_ids[format->id];
+
+  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_FBCONFIG_MASK)
+    _glitz_glx_context_create_using_fbconfig (screen_info,
+                                              format_id,
+                                              screen_info->root_context,
+                                              context);
+  else
+    _glitz_glx_context_create (screen_info,
+                               format_id,
+                               screen_info->root_context,
+                               context);
+
+  if (!screen_info->root_context)
+    screen_info->root_context = context->context;
+
+  memcpy (&context->backend.gl,
+          &_glitz_glx_gl_proc_address,
+          sizeof (glitz_gl_proc_address_list_t));
+
+  context->backend.create_pbuffer = glitz_glx_create_pbuffer;
+  context->backend.destroy = glitz_glx_destroy;
+  context->backend.push_current = glitz_glx_push_current;
+  context->backend.pop_current = glitz_glx_pop_current;
+  context->backend.swap_buffers = glitz_glx_swap_buffers;
+  context->backend.make_current_read = glitz_glx_make_current_read;
+
+  context->backend.drawable_formats = screen_info->formats;
+  context->backend.n_drawable_formats = screen_info->n_formats;
+
+  context->backend.texture_formats = NULL;
+  context->backend.formats = NULL;
+  context->backend.n_formats = 0;
+  
+  context->backend.program_map = &screen_info->program_map;
+  context->backend.feature_mask = 0;
+
+  context->initialized = 0;
+  
+  return context;
+}
+
+void
+glitz_glx_context_destroy (glitz_glx_screen_info_t *screen_info,
+                           glitz_glx_context_t     *context)
+{
+  if (context->backend.formats)
+    free (context->backend.formats);
+
+  if (context->backend.texture_formats)
+    free (context->backend.texture_formats);
+  
+  glXDestroyContext (screen_info->display_info->display,
+                     context->context);
+  free (context);
+}
+
+static void
+_glitz_glx_context_initialize (glitz_glx_screen_info_t *screen_info,
+                               glitz_glx_context_t     *context)
+{
+  glitz_backend_init (&context->backend,
+                      glitz_glx_get_proc_address,
+                      (void *) screen_info);
+
+  context->backend.gl.get_integer_v (GLITZ_GL_MAX_VIEWPORT_DIMS,
+                                     context->max_viewport_dims);
+
+  glitz_initiate_state (&_glitz_glx_gl_proc_address);
+    
+  context->initialized = 1;
+}
+
+static void
+_glitz_glx_context_make_current (glitz_glx_drawable_t *drawable,
+                                 glitz_bool_t         flush)
+{
+  if (flush)
+    glFlush ();
+
+  glXMakeCurrent (drawable->screen_info->display_info->display,
+                  drawable->drawable,
+                  drawable->context->context);
+
+  drawable->base.update_all = 1;
+  
+  if (!drawable->context->initialized)
+    _glitz_glx_context_initialize (drawable->screen_info, drawable->context);
+}
+
+static void
+_glitz_glx_context_update (glitz_glx_drawable_t *drawable,
+                           glitz_constraint_t   constraint)
+{
+  GLXContext context;
+  
+  switch (constraint) {
+  case GLITZ_NONE:
+    break;
+  case GLITZ_ANY_CONTEXT_CURRENT:
+    context = glXGetCurrentContext ();
+    if (context == (GLXContext) 0)
+      _glitz_glx_context_make_current (drawable, 0);
+    break;
+  case GLITZ_CONTEXT_CURRENT:
+    context = glXGetCurrentContext ();
+    if (context != drawable->context->context)
+      _glitz_glx_context_make_current (drawable, (context)? 1: 0);
+    break;
+  case GLITZ_DRAWABLE_CURRENT:
+    context = glXGetCurrentContext ();
+    if ((context != drawable->context->context) ||
+        (glXGetCurrentDrawable () != drawable->drawable))
+      _glitz_glx_context_make_current (drawable, (context)? 1: 0);
+    break;
+  }
+}
+
+void
+glitz_glx_push_current (void               *abstract_drawable,
+                        glitz_surface_t    *surface,
+                        glitz_constraint_t constraint)
+{
+  glitz_glx_drawable_t *drawable = (glitz_glx_drawable_t *) abstract_drawable;
+  glitz_glx_context_info_t *context_info;
+  int index;
+
+  index = drawable->screen_info->context_stack_size++;
+
+  context_info = &drawable->screen_info->context_stack[index];
+  context_info->drawable = drawable;
+  context_info->surface = surface;
+  context_info->constraint = constraint;
+  
+  _glitz_glx_context_update (context_info->drawable, constraint);
+}
+
+glitz_surface_t *
+glitz_glx_pop_current (void *abstract_drawable)
+{
+  glitz_glx_drawable_t *drawable = (glitz_glx_drawable_t *) abstract_drawable;
+  glitz_glx_context_info_t *context_info = NULL;
+  int index;
+
+  drawable->screen_info->context_stack_size--;
+  index = drawable->screen_info->context_stack_size - 1;
+
+  context_info = &drawable->screen_info->context_stack[index];
+
+  if (context_info->drawable)
+    _glitz_glx_context_update (context_info->drawable,
+                               context_info->constraint);
+  
+  if (context_info->constraint == GLITZ_DRAWABLE_CURRENT)
+      return context_info->surface;
+  
+  return NULL;
+}
diff --git a/src/glx/glitz_glx_drawable.c b/src/glx/glitz_glx_drawable.c
new file mode 100644
index 0000000..7c70a14
--- /dev/null
+++ b/src/glx/glitz_glx_drawable.c
@@ -0,0 +1,210 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_glxint.h"
+
+glitz_status_t
+glitz_glx_make_current_read (void *abstract_surface)
+{
+  return GLITZ_STATUS_NOT_SUPPORTED;
+}
+
+static glitz_glx_drawable_t *
+_glitz_glx_create_drawable (glitz_glx_screen_info_t *screen_info,
+                            glitz_glx_context_t     *context,
+                            glitz_drawable_format_t *format,
+                            GLXDrawable             glx_drawable,
+                            GLXPbuffer              glx_pbuffer,
+                            int                     width,
+                            int                     height)
+{
+  glitz_glx_drawable_t *drawable;
+  
+  if (width <= 0 || height <= 0)
+    return NULL;
+
+  drawable = (glitz_glx_drawable_t *) malloc (sizeof (glitz_glx_drawable_t));
+  if (drawable == NULL)
+    return NULL;
+
+  drawable->base.ref_count = 1;
+  drawable->screen_info = screen_info;
+  drawable->context = context;
+  drawable->drawable = glx_drawable;
+  drawable->pbuffer = glx_pbuffer;
+  drawable->base.format = format;
+  drawable->base.backend = &context->backend;
+
+  glitz_drawable_update_size (&drawable->base, width, height);
+
+  if (!context->initialized) {
+    glitz_glx_push_current (drawable, NULL, GLITZ_CONTEXT_CURRENT);
+    glitz_glx_pop_current (drawable);
+  }
+  
+  if (width > context->max_viewport_dims[0] ||
+      height > context->max_viewport_dims[1]) {
+    free (drawable);
+    return NULL;
+  }
+
+  screen_info->drawables++;
+  
+  return drawable;
+}
+
+static glitz_drawable_t *
+_glitz_glx_create_pbuffer_drawable (glitz_glx_screen_info_t    *screen_info,
+                                    glitz_drawable_format_t    *format,
+                                    glitz_pbuffer_attributes_t *attributes,
+                                    unsigned long              mask)
+{
+  glitz_glx_drawable_t *drawable;
+  glitz_glx_context_t *context;
+  unsigned int width, height;
+  GLXPbuffer pbuffer;
+
+  if (!format->types.pbuffer)
+    return NULL;
+  
+  context = glitz_glx_context_get (screen_info, format);
+  if (!context)
+    return NULL;
+
+  pbuffer = glitz_glx_pbuffer_create (screen_info, context->fbconfig,
+                                      attributes, mask,
+                                      &width, &height);
+  if (!pbuffer)
+    return NULL;
+  
+  drawable = _glitz_glx_create_drawable (screen_info, context, format,
+                                         pbuffer, pbuffer,
+                                         width, height);
+  if (!drawable) {
+    glitz_glx_pbuffer_destroy (screen_info, pbuffer);
+    return NULL;
+  }
+  
+  return &drawable->base;
+}
+
+glitz_drawable_t *
+glitz_glx_create_pbuffer (void                       *abstract_templ,
+                          glitz_drawable_format_t    *format,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask)
+{
+  glitz_glx_drawable_t *templ = (glitz_glx_drawable_t *) abstract_templ;
+
+  return _glitz_glx_create_pbuffer_drawable (templ->screen_info, format,
+                                             attributes, mask);
+}
+
+glitz_drawable_t *
+glitz_glx_create_drawable_for_window (Display                 *display,
+                                      int                     screen,
+                                      glitz_drawable_format_t *format,
+                                      Window                  window,
+                                      int                     width,
+                                      int                     height)
+{
+  glitz_glx_drawable_t *drawable;
+  glitz_glx_screen_info_t *screen_info;
+  glitz_glx_context_t *context;
+
+  screen_info = glitz_glx_screen_info_get (display, screen);
+  if (!screen_info)
+    return NULL;
+ 
+  context = glitz_glx_context_get (screen_info, format);
+  if (!context)
+    return NULL;
+  
+  drawable = _glitz_glx_create_drawable (screen_info, context, format,
+                                         window, (GLXPbuffer) 0,
+                                         width, height);
+  if (!drawable)
+    return NULL;
+
+  return &drawable->base;
+}
+slim_hidden_def(glitz_glx_create_drawable_for_window);
+
+glitz_drawable_t *
+glitz_glx_create_pbuffer_drawable (Display                    *display,
+                                   int                        screen,
+                                   glitz_drawable_format_t    *format,
+                                   glitz_pbuffer_attributes_t *attributes,
+                                   unsigned long              mask)
+{
+  glitz_glx_screen_info_t *screen_info;
+
+  screen_info = glitz_glx_screen_info_get (display, screen);
+  if (!screen_info)
+    return NULL;
+
+  return _glitz_glx_create_pbuffer_drawable (screen_info, format,
+                                             attributes, mask);
+}
+slim_hidden_def(glitz_glx_create_pbuffer_drawable);
+
+void
+glitz_glx_destroy (void *abstract_drawable)
+{
+  glitz_glx_drawable_t *drawable = (glitz_glx_drawable_t *) abstract_drawable;
+
+  drawable->screen_info->drawables--;
+  if (drawable->screen_info->drawables == 0) {
+    /*
+     * Last drawable? We have to destroy all fragment programs as this may
+     * be our last chance to have a context current.
+     */
+    glitz_glx_push_current (abstract_drawable, NULL, GLITZ_CONTEXT_CURRENT);
+    glitz_program_map_fini (&drawable->base.backend->gl,
+                            &drawable->screen_info->program_map);
+    glitz_glx_pop_current (abstract_drawable);
+  }
+
+  if (glXGetCurrentDrawable () == drawable->drawable)
+    glXMakeCurrent (drawable->screen_info->display_info->display, None, NULL);
+  
+  if (drawable->pbuffer)
+    glitz_glx_pbuffer_destroy (drawable->screen_info, drawable->pbuffer);
+  
+  free (drawable);
+}
+
+void
+glitz_glx_swap_buffers (void *abstract_drawable)
+{
+  glitz_glx_drawable_t *drawable = (glitz_glx_drawable_t *) abstract_drawable;
+
+  glXSwapBuffers (drawable->screen_info->display_info->display,
+                  drawable->drawable);
+}
diff --git a/src/glx/glitz_glx_extension.c b/src/glx/glitz_glx_extension.c
new file mode 100644
index 0000000..efa089f
--- /dev/null
+++ b/src/glx/glitz_glx_extension.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_glxint.h"
+
+static glitz_extension_map glx_extensions[] = {
+  { 0.0, "GLX_SGIX_fbconfig", GLITZ_GLX_FEATURE_FBCONFIG_MASK },
+  { 0.0, "GLX_SGIX_pbuffer", GLITZ_GLX_FEATURE_PBUFFER_MASK },
+  { 0.0, "GLX_SGI_make_current_read",
+    GLITZ_GLX_FEATURE_MAKE_CURRENT_READ_MASK },
+  { 0.0, "GLX_ARB_multisample", GLITZ_GLX_FEATURE_MULTISAMPLE_MASK },
+  { 0.0, NULL, 0 }
+};
+
+void
+glitz_glx_query_extensions (glitz_glx_screen_info_t *screen_info,
+                            glitz_gl_float_t        glx_version)
+{
+  const char *glx_extensions_string;
+
+  glx_extensions_string =
+    glXQueryExtensionsString (screen_info->display_info->display,
+                              screen_info->screen);
+  
+  screen_info->glx_feature_mask =
+    glitz_extensions_query (glx_version,
+                            glx_extensions_string,
+                            glx_extensions);
+  
+  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTISAMPLE_MASK) {
+    const char *vendor;
+
+    vendor = glXGetClientString (screen_info->display_info->display,
+                                 GLX_VENDOR);
+    
+    if (vendor) {
+      
+      /* NVIDIA's driver seem to support multisample with pbuffers */
+      if (!strncmp ("NVIDIA", vendor, 6))
+        screen_info->glx_feature_mask |=
+          GLITZ_GLX_FEATURE_PBUFFER_MULTISAMPLE_MASK;
+    }
+  }
+}
diff --git a/src/glx/glitz_glx_format.c b/src/glx/glitz_glx_format.c
new file mode 100644
index 0000000..f4aaf0b
--- /dev/null
+++ b/src/glx/glitz_glx_format.c
@@ -0,0 +1,363 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_glxint.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static int
+_glitz_glx_format_compare (const void *elem1,
+                           const void *elem2)
+{
+  int i, score[2];
+  glitz_drawable_format_t *format[2];
+  
+  format[0] = (glitz_drawable_format_t *) elem1;
+  format[1] = (glitz_drawable_format_t *) elem2;
+  i = score[0] = score[1] = 0;
+
+  for (; i < 2; i++) {
+    if (format[i]->color.red_size) {
+      if (format[i]->color.red_size == 8)
+        score[i] += 5;
+      score[i] += 10;
+    }
+
+    if (format[i]->color.green_size) {
+      if (format[i]->color.green_size == 8)
+        score[i] += 5;
+      score[i] += 10;
+    }
+    
+    if (format[i]->color.alpha_size) {
+      if (format[i]->color.alpha_size == 8)
+        score[i] += 5;
+      score[i] += 10;
+    }
+
+    if (format[i]->stencil_size)
+      score[i] += 5;
+
+    if (format[i]->depth_size)
+      score[i] += 5;
+
+    if (format[i]->doublebuffer)
+      score[i] += 10;
+    
+    if (format[i]->types.window)
+      score[i] += 10;
+    
+    if (format[i]->types.pbuffer)
+      score[i] += 10;
+    
+    if (format[i]->samples > 1) 
+      score[i] -= (20 - format[i]->samples);
+  }
+  
+  return score[1] - score[0];
+}
+
+static void
+_glitz_add_format (glitz_glx_screen_info_t *screen_info,
+                   glitz_drawable_format_t *format,
+                   XID                     id)
+{
+  if (!glitz_drawable_format_find (screen_info->formats,
+                                   screen_info->n_formats,
+                                   GLITZ_DRAWABLE_FORMAT_ALL_EXCEPT_ID_MASK,
+                                   format, 0)) {
+    int n = screen_info->n_formats;
+    
+    screen_info->formats =
+      realloc (screen_info->formats,
+               sizeof (glitz_drawable_format_t) * (n + 1));
+    screen_info->format_ids =
+      realloc (screen_info->format_ids, sizeof (XID) * (n + 1));
+
+    if (screen_info->formats && screen_info->format_ids) {
+      screen_info->formats[n] = *format;
+      screen_info->formats[n].id = n;
+      screen_info->format_ids[n] = id;
+      screen_info->n_formats++;
+    }
+  }
+}
+
+static void
+_glitz_glx_query_formats (glitz_glx_screen_info_t *screen_info)
+{
+  Display *display;
+  glitz_drawable_format_t format;
+  XVisualInfo visual_templ;
+  XVisualInfo *visuals;
+  int i, num_visuals;
+  
+  display = screen_info->display_info->display;
+
+  visual_templ.screen = screen_info->screen;
+  visuals = XGetVisualInfo (display, VisualScreenMask,
+                            &visual_templ, &num_visuals);
+
+  /* No pbuffers without fbconfigs */
+  format.types.window = 1;
+  format.types.pbuffer = 0;
+  format.id = 0;
+
+  for (i = 0; i < num_visuals; i++) {
+    int value;
+    
+    if ((glXGetConfig (display, &visuals[i], GLX_USE_GL, &value) != 0) ||
+        (value == 0))
+      continue;
+    
+    glXGetConfig (display, &visuals[i], GLX_RGBA, &value);
+    if (value == 0)
+      continue;
+
+    /* Stereo is not supported yet */
+    glXGetConfig (display, &visuals[i], GLX_STEREO, &value);
+    if (value != 0)
+      continue;
+    
+    glXGetConfig (display, &visuals[i], GLX_RED_SIZE, &value);
+    format.color.red_size = (unsigned short) value;
+    glXGetConfig (display, &visuals[i], GLX_GREEN_SIZE, &value);
+    format.color.green_size = (unsigned short) value;
+    glXGetConfig (display, &visuals[i], GLX_BLUE_SIZE, &value);
+    format.color.blue_size = (unsigned short) value;
+    glXGetConfig (display, &visuals[i], GLX_ALPHA_SIZE, &value);
+    format.color.alpha_size = (unsigned short) value;
+    glXGetConfig (display, &visuals[i], GLX_DEPTH_SIZE, &value);
+    format.depth_size = (unsigned short) value;
+    glXGetConfig (display, &visuals[i], GLX_STENCIL_SIZE, &value);
+    format.stencil_size = (unsigned short) value;
+    glXGetConfig (display, &visuals[i], GLX_DOUBLEBUFFER, &value);
+    format.doublebuffer = (value) ? 1: 0;
+
+    if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTISAMPLE_MASK) {
+      glXGetConfig (display, &visuals[i], GLX_SAMPLE_BUFFERS_ARB, &value);
+      if (value) {
+        glXGetConfig (display, &visuals[i], GLX_SAMPLES_ARB, &value);
+        format.samples = (unsigned short) (value > 1)? value: 1;
+      } else
+        format.samples = 1;
+    } else
+      format.samples = 1;
+    
+    _glitz_add_format (screen_info, &format, visuals[i].visualid);
+  }
+  
+  if (visuals)
+    XFree (visuals);
+}
+
+static glitz_status_t
+_glitz_glx_query_formats_using_fbconfigs (glitz_glx_screen_info_t *screen_info)
+{
+  glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
+  Display *display;
+  glitz_drawable_format_t format;
+  GLXFBConfig *fbconfigs;
+  int i, num_configs;
+  XID id;
+  
+  display = screen_info->display_info->display;
+
+  fbconfigs = glx->get_fbconfigs (display, screen_info->screen, &num_configs);
+  if (!fbconfigs) {
+    /* fbconfigs are not supported, falling back to visuals */
+    screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_FBCONFIG_MASK;
+    screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_PBUFFER_MASK;
+    
+    return GLITZ_STATUS_NOT_SUPPORTED;
+  }
+
+  for (i = 0; i < num_configs; i++) {
+    int value;
+    
+    if ((glx->get_fbconfig_attrib (display, fbconfigs[i],
+                                   GLX_RENDER_TYPE, &value) != 0) ||
+        (!(value & GLX_RGBA_BIT)))
+      continue;
+
+    /* Stereo is not supported yet */
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_STEREO, &value);
+    if (value != 0)
+      continue;
+
+    glx->get_fbconfig_attrib (display, fbconfigs[i],
+                              GLX_DRAWABLE_TYPE, &value);
+    if (!((value & GLX_WINDOW_BIT) || (value & GLX_PBUFFER_BIT)))
+      continue;
+    
+    format.types.window = (value & GLX_WINDOW_BIT)? 1: 0;
+    format.types.pbuffer = (value & GLX_PBUFFER_BIT)? 1: 0;
+    format.id = 0;
+    
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_FBCONFIG_ID, &value);
+    id = (XID) value;
+
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_RED_SIZE, &value);
+    format.color.red_size = (unsigned short) value;
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_GREEN_SIZE, &value);
+    format.color.green_size = (unsigned short) value;
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_BLUE_SIZE, &value);
+    format.color.blue_size = (unsigned short) value;
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_ALPHA_SIZE, &value);
+    format.color.alpha_size = (unsigned short) value;
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_DEPTH_SIZE, &value);
+    format.depth_size = (unsigned short) value;
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_STENCIL_SIZE, &value);
+    format.stencil_size = (unsigned short) value;
+    glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_DOUBLEBUFFER, &value);
+    format.doublebuffer = (value)? 1: 0;
+
+    if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTISAMPLE_MASK) {
+      glx->get_fbconfig_attrib (display, fbconfigs[i],
+                                GLX_SAMPLE_BUFFERS_ARB, &value);
+      if (value) {
+        glx->get_fbconfig_attrib (display, fbconfigs[i],
+                                  GLX_SAMPLES_ARB, &value);
+        format.samples = (unsigned short) (value > 1)? value: 1;
+        if (format.samples > 1) {
+          if (!(screen_info->glx_feature_mask &
+                GLITZ_GLX_FEATURE_PBUFFER_MULTISAMPLE_MASK))
+            format.types.pbuffer = 0;
+        }
+      } else
+        format.samples = 1;
+    } else
+      format.samples = 1;
+    
+    _glitz_add_format (screen_info, &format, id);
+  }
+  
+  if (fbconfigs)
+    XFree (fbconfigs);
+
+  return GLITZ_STATUS_SUCCESS;
+}
+
+void
+glitz_glx_query_formats (glitz_glx_screen_info_t *screen_info)
+{
+  glitz_status_t status = GLITZ_STATUS_NOT_SUPPORTED;
+  XID *new_ids;
+  int i;
+
+  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_FBCONFIG_MASK)
+    status = _glitz_glx_query_formats_using_fbconfigs (screen_info);
+
+  if (status)
+    _glitz_glx_query_formats (screen_info);
+
+  if (!screen_info->n_formats)
+    return;
+
+  qsort (screen_info->formats, screen_info->n_formats, 
+         sizeof (glitz_drawable_format_t), _glitz_glx_format_compare);
+
+  /*
+   * Update XID list so that it matches the sorted format list.
+   */
+  new_ids = malloc (sizeof (XID) * screen_info->n_formats);
+  if (!new_ids) {
+    screen_info->n_formats = 0;
+    return;
+  }
+  
+  for (i = 0; i < screen_info->n_formats; i++) {
+    new_ids[i] = screen_info->format_ids[screen_info->formats[i].id];
+    screen_info->formats[i].id = i;
+  }
+  
+  free (screen_info->format_ids);
+  screen_info->format_ids = new_ids;
+}
+
+glitz_drawable_format_t *
+glitz_glx_find_drawable_format (Display                       *display,
+                                int                           screen,
+                                unsigned long                 mask,
+                                const glitz_drawable_format_t *templ,
+                                int                           count)
+{
+  glitz_glx_screen_info_t *screen_info =
+    glitz_glx_screen_info_get (display, screen);
+
+  return glitz_drawable_format_find (screen_info->formats,
+                                     screen_info->n_formats,
+                                     mask, templ, count);
+}
+slim_hidden_def(glitz_glx_find_drawable_format);
+
+XVisualInfo *
+glitz_glx_get_visual_info_from_format (Display                 *display,
+                                       int                     screen,
+                                       glitz_drawable_format_t *format)
+{
+  XVisualInfo *vinfo = NULL;
+  glitz_glx_screen_info_t *screen_info =
+    glitz_glx_screen_info_get (display, screen);
+  glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
+
+  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_FBCONFIG_MASK) {
+    GLXFBConfig *fbconfigs;
+    int i, n_fbconfigs;
+    int fbconfigid = screen_info->format_ids[format->id];
+
+    fbconfigs = glx->get_fbconfigs (display, screen, &n_fbconfigs);
+    for (i = 0; i < n_fbconfigs; i++) {
+      int value;
+      
+      glx->get_fbconfig_attrib (display, fbconfigs[i],
+                                GLX_FBCONFIG_ID, &value);
+      if (value == fbconfigid)
+        break;
+    }
+    
+    if (i < n_fbconfigs)
+      vinfo = glx->get_visual_from_fbconfig (display, fbconfigs[i]);
+    
+    if (fbconfigs)
+      XFree (fbconfigs);
+    
+  } else {
+    XVisualInfo templ;
+    int n_items;
+    
+    templ.visualid = screen_info->format_ids[format->id];
+    
+    vinfo = XGetVisualInfo (display, VisualIDMask, &templ, &n_items);
+  }
+  
+  return vinfo;
+}
+slim_hidden_def(glitz_glx_get_visual_info_from_format);
diff --git a/src/glitz_glx_info.c b/src/glx/glitz_glx_info.c
index d85a748..47bef56 100644
--- a/src/glitz_glx_info.c
+++ b/src/glx/glitz_glx_info.c
@@ -1,28 +1,26 @@
 /*
- * Copyright © 2004 David Reveman, Peter Nilsson
- *
+ * Copyright © 2004 David Reveman
+ * 
  * 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 names of
- * David Reveman and Peter Nilsson not be used in advertising or
- * publicity pertaining to distribution of the software without
- * specific, written prior permission. David Reveman and Peter Nilsson
- * makes no representations about the suitability of this software for
- * any purpose. It is provided "as is" without express or implied warranty.
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
  *
- * DAVID REVEMAN AND PETER NILSSON DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DAVID REVEMAN AND
- * PETER NILSSON 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.
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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: David Reveman <c99drn@cs.umu.se>
- *          Peter Nilsson <c99pnn@cs.umu.se>
+ * Author: David Reveman <c99drn@cs.umu.se>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -35,9 +33,12 @@
 #include <dlfcn.h>
 
 glitz_gl_proc_address_list_t _glitz_glx_gl_proc_address = {
+
+  /* core */
   (glitz_gl_enable_t) glEnable,
   (glitz_gl_disable_t) glDisable,
   (glitz_gl_get_error_t) glGetError,
+  (glitz_gl_get_string_t) glGetString,
   (glitz_gl_enable_client_state_t) glEnableClientState,
   (glitz_gl_disable_client_state_t) glDisableClientState,
   (glitz_gl_vertex_pointer_t) glVertexPointer,
@@ -92,6 +93,7 @@ glitz_gl_proc_address_list_t _glitz_glx_gl_proc_address = {
   (glitz_gl_copy_tex_sub_image_2d_t) glCopyTexSubImage2D,
   (glitz_gl_get_integer_v_t) glGetIntegerv,
 
+  /* extensions */
   (glitz_gl_blend_color_t) 0,
   (glitz_gl_active_texture_t) 0,
   (glitz_gl_gen_programs_t) 0,
@@ -107,20 +109,18 @@ glitz_gl_proc_address_list_t _glitz_glx_gl_proc_address = {
   (glitz_gl_buffer_sub_data_t) 0,
   (glitz_gl_get_buffer_sub_data_t) 0,
   (glitz_gl_map_buffer_t) 0,
-  (glitz_gl_unmap_buffer_t) 0,
-  
-  1
+  (glitz_gl_unmap_buffer_t) 0
 };
 
 glitz_function_pointer_t
-glitz_glx_get_proc_address (glitz_glx_screen_info_t *screen_info,
-                            const char *name)
+glitz_glx_get_proc_address (const char *name,
+                            void       *closure)
 {
-  glitz_function_pointer_t address = NULL;
+  glitz_glx_screen_info_t *screen_info = (glitz_glx_screen_info_t *) closure;
   glitz_glx_thread_info_t *info = screen_info->display_info->thread_info;
+  glitz_function_pointer_t address = NULL;
 
-  if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_GLX_GET_PROC_ADDRESS_MASK)
+  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GET_PROC_ADDRESS_MASK)
     address = screen_info->glx.get_proc_address ((glitz_gl_ubyte_t *) name);
   
   if (!address) {
@@ -141,89 +141,108 @@ glitz_glx_get_proc_address (glitz_glx_screen_info_t *screen_info,
 static void
 _glitz_glx_proc_address_lookup (glitz_glx_screen_info_t *screen_info)
 {
-  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK) {
+  if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_FBCONFIG_MASK) {
     if (screen_info->glx_version >= 1.3f) {
       screen_info->glx.get_fbconfigs = (glitz_glx_get_fbconfigs_t)
-        glitz_glx_get_proc_address (screen_info, "glXGetFBConfigs");
+        glitz_glx_get_proc_address ("glXGetFBConfigs", (void *) screen_info);
       screen_info->glx.get_fbconfig_attrib = (glitz_glx_get_fbconfig_attrib_t)
-        glitz_glx_get_proc_address (screen_info, "glXGetFBConfigAttrib");
+        glitz_glx_get_proc_address ("glXGetFBConfigAttrib",
+                                    (void *) screen_info);
       screen_info->glx.get_visual_from_fbconfig =
         (glitz_glx_get_visual_from_fbconfig_t)
-        glitz_glx_get_proc_address (screen_info, "glXGetVisualFromFBConfig");
+        glitz_glx_get_proc_address ("glXGetVisualFromFBConfig",
+                                    (void *) screen_info);
       screen_info->glx.create_new_context = (glitz_glx_create_new_context_t)
-        glitz_glx_get_proc_address (screen_info, "glXCreateNewContext");
+        glitz_glx_get_proc_address ("glXCreateNewContext",
+                                    (void *) screen_info);
 
-      if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK) {
+      if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_PBUFFER_MASK) {
         screen_info->glx.create_pbuffer = (glitz_glx_create_pbuffer_t)
-          glitz_glx_get_proc_address (screen_info, "glXCreatePbuffer");
+          glitz_glx_get_proc_address ("glXCreatePbuffer",
+                                      (void *) screen_info);
         screen_info->glx.destroy_pbuffer = (glitz_glx_destroy_pbuffer_t)
-          glitz_glx_get_proc_address (screen_info, "glXDestroyPbuffer");
+          glitz_glx_get_proc_address ("glXDestroyPbuffer",
+                                      (void *) screen_info);
+        screen_info->glx.query_drawable = (glitz_glx_query_drawable_t)
+          glitz_glx_get_proc_address ("glXQueryDrawable",
+                                      (void *) screen_info);
       }      
     } else {
       screen_info->glx.get_fbconfigs = (glitz_glx_get_fbconfigs_t)
-        glitz_glx_get_proc_address (screen_info, "glXGetFBConfigsSGIX");
+        glitz_glx_get_proc_address ("glXGetFBConfigsSGIX",
+                                    (void *) screen_info);
       screen_info->glx.get_fbconfig_attrib = (glitz_glx_get_fbconfig_attrib_t)
-        glitz_glx_get_proc_address (screen_info, "glXGetFBConfigAttribSGIX");
+        glitz_glx_get_proc_address ("glXGetFBConfigAttribSGIX",
+                                    (void *) screen_info);
       screen_info->glx.get_visual_from_fbconfig =
         (glitz_glx_get_visual_from_fbconfig_t)
-        glitz_glx_get_proc_address (screen_info,
-                                    "glXGetVisualFromFBConfigSGIX");
+        glitz_glx_get_proc_address ("glXGetVisualFromFBConfigSGIX",
+                                    (void *) screen_info);
       screen_info->glx.create_new_context = (glitz_glx_create_new_context_t)
-        glitz_glx_get_proc_address (screen_info,
-                                    "glXCreateContextWithConfigSGIX");
+        glitz_glx_get_proc_address ("glXCreateContextWithConfigSGIX",
+                                    (void *) screen_info);
 
-      if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK) {
+      if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_PBUFFER_MASK) {
         screen_info->glx.create_pbuffer = (glitz_glx_create_pbuffer_t)
-          glitz_glx_get_proc_address (screen_info, "glXCreatePbufferSGIX");
+          glitz_glx_get_proc_address ("glXCreateGLXPbufferSGIX",
+                                      (void *) screen_info);
         screen_info->glx.destroy_pbuffer = (glitz_glx_destroy_pbuffer_t)
-          glitz_glx_get_proc_address (screen_info, "glXDestroyPbufferSGIX");
+          glitz_glx_get_proc_address ("glXDestroyGLXPbufferSGIX",
+                                      (void *) screen_info);
+        screen_info->glx.query_drawable = (glitz_glx_query_drawable_t)
+          glitz_glx_get_proc_address ("glXQueryGLXPbufferSGIX",
+                                      (void *) screen_info);
       }
     }
 
     if ((!screen_info->glx.create_pbuffer) ||
-        (!screen_info->glx.destroy_pbuffer))
-      screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK;
+        (!screen_info->glx.destroy_pbuffer) ||
+        (!screen_info->glx.query_drawable))
+      screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_PBUFFER_MASK;
 
     if ((!screen_info->glx.get_fbconfigs) ||
         (!screen_info->glx.get_fbconfig_attrib) ||
         (!screen_info->glx.get_visual_from_fbconfig) ||
         (!screen_info->glx.create_new_context)) {
-      screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_GLX_FBCONFIG_MASK;
-      screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK;
+      screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_FBCONFIG_MASK;
+      screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_PBUFFER_MASK;
     }
   } else
-    screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_GLX_PBUFFER_MASK;
+    screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_PBUFFER_MASK;
 
   if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_GLX_MAKE_CURRENT_READ_MASK) {
+      GLITZ_GLX_FEATURE_MAKE_CURRENT_READ_MASK) {
     if (screen_info->glx_version >= 1.3f) {
       screen_info->glx.make_context_current =
         (glitz_glx_make_context_current_t)
-        glitz_glx_get_proc_address (screen_info, "glXMakeContextCurrent");
+        glitz_glx_get_proc_address ("glXMakeContextCurrent",
+                                    (void *) screen_info);
     } else {
       screen_info->glx.make_context_current =
         (glitz_glx_make_context_current_t)
-        glitz_glx_get_proc_address (screen_info, "glXMakeCurrentReadSGI");
+        glitz_glx_get_proc_address ("glXMakeCurrentReadSGI",
+                                    (void *) screen_info);
     }
       
     if (!screen_info->glx.make_context_current)
       screen_info->glx_feature_mask &=
-        ~GLITZ_GLX_FEATURE_GLX_MAKE_CURRENT_READ_MASK;
+        ~GLITZ_GLX_FEATURE_MAKE_CURRENT_READ_MASK;
   }
   
   if (screen_info->glx_feature_mask &
-      GLITZ_GLX_FEATURE_GLX_GET_PROC_ADDRESS_MASK) {
+      GLITZ_GLX_FEATURE_GET_PROC_ADDRESS_MASK) {
     if (screen_info->glx_version >= 1.4f) {
       screen_info->glx.get_proc_address = (glitz_glx_get_proc_address_t)
-        glitz_glx_get_proc_address (screen_info, "glXGetProcAddress");
+        glitz_glx_get_proc_address ("glXGetProcAddress", (void *) screen_info);
     } else {
       screen_info->glx.get_proc_address = (glitz_glx_get_proc_address_t)
-        glitz_glx_get_proc_address (screen_info, "glXGetProcAddressARB");
+        glitz_glx_get_proc_address ("glXGetProcAddressARB",
+                                    (void *) screen_info);
     }
 
     if (!screen_info->glx.get_proc_address)
       screen_info->glx_feature_mask &=
-        ~GLITZ_GLX_FEATURE_GLX_GET_PROC_ADDRESS_MASK;
+        ~GLITZ_GLX_FEATURE_GET_PROC_ADDRESS_MASK;
   }
 }
 
@@ -417,76 +436,9 @@ _glitz_glx_display_destroy (glitz_glx_display_info_t *display_info)
   free (display_info);
 }
 
-static void
-_glitz_glx_create_root_context (glitz_glx_screen_info_t *screen_info)
-{
-  XVisualInfo *vinfo;
-  XSetWindowAttributes win_attrib;
-  static int attrib_double[] = {
-    GLX_RGBA,
-    GLX_RED_SIZE, 1,
-    GLX_DOUBLEBUFFER,
-    None
-  };
-  static int attrib_single[] = {
-    GLX_RGBA,
-    GLX_RED_SIZE, 1,
-    None
-  };
-  int screen = screen_info->screen;
-  Display *display = screen_info->display_info->display;
-
-  vinfo = glXChooseVisual (display, screen, attrib_double);
-  if (!vinfo)
-    vinfo = glXChooseVisual (display, screen, attrib_single);
-  
-  if (vinfo) {
-    screen_info->root_colormap = XCreateColormap (display,
-                                                  RootWindow (display, screen),
-                                                  vinfo->visual, AllocNone);
-    win_attrib.background_pixel = 0;
-    win_attrib.border_pixel = 0;
-    win_attrib.event_mask = StructureNotifyMask | ExposureMask;
-    win_attrib.colormap = screen_info->root_colormap;
-
-    screen_info->root_drawable =
-      XCreateWindow (display, RootWindow (display, screen),
-                     -1, -1, 1, 1, 0, vinfo->depth, InputOutput,
-                     vinfo->visual,
-                     CWBackPixel | CWBorderPixel | CWColormap | CWEventMask,
-                     &win_attrib);
-    
-    screen_info->root_context.context =
-      glXCreateContext (display, vinfo, NULL, 1);
-    
-    screen_info->root_context.id = vinfo->visualid;
-    
-    XFree (vinfo);
-  } else {
-    screen_info->root_drawable = None;
-    screen_info->root_context.context = NULL;
-    screen_info->root_context.id = 0;
-  }
-
-  screen_info->root_context.fbconfig = (XID) 0;
-
-  glitz_glx_surface_backend_init (&screen_info->root_context.backend);
-  
-  memcpy (&screen_info->root_context.backend.gl,
-          &_glitz_glx_gl_proc_address,
-          sizeof (glitz_gl_proc_address_list_t));
-
-  screen_info->root_context.backend.formats = NULL;
-  screen_info->root_context.backend.n_formats = 0;
-  screen_info->root_context.backend.program_map = NULL;
-  screen_info->root_context.backend.feature_mask = 0;
-  
-  screen_info->root_context.backend.gl.need_lookup = 1;
-}
-
 glitz_glx_screen_info_t *
 glitz_glx_screen_info_get (Display *display,
-                           int screen)
+                           int     screen)
 {
   glitz_glx_screen_info_t *screen_info;
   glitz_glx_display_info_t *display_info =
@@ -503,12 +455,13 @@ glitz_glx_screen_info_get (Display *display,
   display_info->screens =
     realloc (display_info->screens,
              sizeof (glitz_glx_screen_info_t *) * display_info->n_screens);
-
+  
   screen_info = malloc (sizeof (glitz_glx_screen_info_t));
   display_info->screens[index] = screen_info;
-
+  
   screen_info->display_info = display_info;
   screen_info->screen = screen;
+  screen_info->drawables = 0;
   screen_info->formats = NULL;
   screen_info->format_ids = NULL;
   screen_info->n_formats = 0;
@@ -520,43 +473,26 @@ glitz_glx_screen_info_get (Display *display,
 
   glitz_program_map_init (&screen_info->program_map);
   
-  screen_info->root_context.context = (GLXContext) 0;
+  screen_info->root_context = (GLXContext) 0;
+  screen_info->glx_feature_mask = 0;
 
   if (glXQueryExtension (display, &error_base, &event_base)) {
     int major, minor;
     
     if (glXQueryVersion (display, &major, &minor)) {
       screen_info->glx_version = major + minor / 10.0f;
-      if (major > 1 || (major > 0 || minor >= 2))
-        _glitz_glx_create_root_context (screen_info);
-    }
-  }
-
-  screen_info->glx_feature_mask = screen_info->feature_mask = 0;
-
-  if (screen_info->root_context.context &&
-      glXMakeCurrent (screen_info->display_info->display,
-                      screen_info->root_drawable,
-                      screen_info->root_context.context)) {
-    if (glitz_glx_query_extensions (screen_info) == GLITZ_STATUS_SUCCESS) {
-        screen_info->root_context.backend.feature_mask =
-          screen_info->feature_mask;
-
+      if (major > 1 || (major > 0 || minor >= 2)) {
+        glitz_glx_query_extensions (screen_info, screen_info->glx_version);
         _glitz_glx_proc_address_lookup (screen_info);
-        
-        glitz_glx_context_proc_address_lookup (screen_info,
-                                               &screen_info->root_context);
         glitz_glx_query_formats (screen_info);
+      }
     }
   }
 
-  screen_info->root_context.backend.formats = screen_info->formats;
-  screen_info->root_context.backend.n_formats = screen_info->n_formats;
-  screen_info->root_context.backend.program_map = &screen_info->program_map;
-  
   screen_info->context_stack_size = 1;
+  screen_info->context_stack->drawable = NULL;
   screen_info->context_stack->surface = NULL;
-  screen_info->context_stack->constraint = GLITZ_CN_NONE;
+  screen_info->context_stack->constraint = GLITZ_NONE;
   
   return screen_info;
 }
@@ -564,17 +500,11 @@ glitz_glx_screen_info_get (Display *display,
 static void
 _glitz_glx_screen_destroy (glitz_glx_screen_info_t *screen_info)
 {
-  int i;
   Display *display = screen_info->display_info->display;
+  int     i;
 
-  if (screen_info->root_context.context &&
-      glXMakeCurrent (screen_info->display_info->display,
-                      screen_info->root_drawable,
-                      screen_info->root_context.context)) {
-    glitz_program_map_fini (&screen_info->root_context.backend.gl,
-                            &screen_info->program_map);
+  if (screen_info->root_context)
     glXMakeCurrent (display, None, NULL);
-  }
   
   for (i = 0; i < screen_info->n_contexts; i++)
     glitz_glx_context_destroy (screen_info, screen_info->contexts[i]);
@@ -587,15 +517,6 @@ _glitz_glx_screen_destroy (glitz_glx_screen_info_t *screen_info)
 
   if (screen_info->format_ids)
     free (screen_info->format_ids);
-  
-  if (screen_info->root_context.context)
-    glXDestroyContext (display, screen_info->root_context.context);
-  
-  if (screen_info->root_drawable)
-    XDestroyWindow (display, screen_info->root_drawable);
-
-  if (screen_info->root_colormap)
-    XFreeColormap (display, screen_info->root_colormap);
 
   free (screen_info);
 }
diff --git a/src/glx/glitz_glx_pbuffer.c b/src/glx/glitz_glx_pbuffer.c
new file mode 100644
index 0000000..9506322
--- /dev/null
+++ b/src/glx/glitz_glx_pbuffer.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "../config.h"
+#endif
+
+#include "glitz_glxint.h"
+
+GLXPbuffer
+glitz_glx_pbuffer_create (glitz_glx_screen_info_t    *screen_info,
+                          GLXFBConfig                fbconfig,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask,
+                          unsigned int               *width,
+                          unsigned int               *height)
+{
+  if (fbconfig) {
+    GLXPbuffer pbuffer;
+    int pbuffer_attr[13];
+    int i = 0;
+
+    pbuffer_attr[i++] = GLX_PBUFFER_WIDTH;
+    if (mask & GLITZ_PBUFFER_WIDTH_MASK)
+      pbuffer_attr[i++] = attributes->width;
+    else
+      pbuffer_attr[i++] = GLITZ_DEFAULT_PBUFFER_WIDTH;
+
+    pbuffer_attr[i++] = GLX_PBUFFER_HEIGHT;
+    if (mask & GLITZ_PBUFFER_HEIGHT_MASK)
+      pbuffer_attr[i++] = attributes->height;
+    else
+      pbuffer_attr[i++] = GLITZ_DEFAULT_PBUFFER_HEIGHT;
+    
+    pbuffer_attr[i++] = GLX_LARGEST_PBUFFER;
+    pbuffer_attr[i++] = 1;
+
+    pbuffer_attr[i++] = GLX_PRESERVED_CONTENTS;
+    pbuffer_attr[i++] = 1;
+    pbuffer_attr[i++] = 0;
+
+    pbuffer =
+      screen_info->glx.create_pbuffer (screen_info->display_info->display,
+                                       fbconfig, pbuffer_attr);
+    if (!pbuffer)
+      return (GLXPbuffer) 0;
+
+    screen_info->glx.query_drawable (screen_info->display_info->display,
+                                     pbuffer, GLX_WIDTH, width);
+
+    screen_info->glx.query_drawable (screen_info->display_info->display,
+                                     pbuffer, GLX_HEIGHT, height);
+    return pbuffer;
+  } else
+    return (GLXPbuffer) 0;
+}
+
+void 
+glitz_glx_pbuffer_destroy (glitz_glx_screen_info_t *screen_info,
+                           GLXPbuffer              pbuffer)
+{
+  screen_info->glx.destroy_pbuffer (screen_info->display_info->display,
+                                    pbuffer);
+}
diff --git a/src/glitz_glxext.h b/src/glx/glitz_glxext.h
index 9f97452..9d3bea4 100644
--- a/src/glitz_glxext.h
+++ b/src/glx/glitz_glxext.h
@@ -106,6 +106,9 @@ typedef GLXPbuffer (* glitz_glx_create_pbuffer_t)
      (Display *display, GLXFBConfig config, const int *attrib_list);
 typedef void (* glitz_glx_destroy_pbuffer_t)
      (Display *display, GLXPbuffer pbuffer);
+typedef void (* glitz_glx_query_drawable_t)
+     (Display *display, GLXDrawable drawable,
+      int attribute, unsigned int *value);
 typedef Bool (* glitz_glx_make_context_current_t)
      (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
 typedef GLXContext (* glitz_glx_create_new_context_t)
diff --git a/src/glx/glitz_glxint.h b/src/glx/glitz_glxint.h
new file mode 100644
index 0000000..9814511
--- /dev/null
+++ b/src/glx/glitz_glxint.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright © 2004 David Reveman
+ * 
+ * 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 names of
+ * David Reveman not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * David Reveman makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DAVID REVEMAN 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.
+ *
+ * Author: David Reveman <c99drn@cs.umu.se>
+ */
+
+#ifndef GLITZ_GLXINT_H_INCLUDED
+#define GLITZ_GLXINT_H_INCLUDED
+
+#include "glitz.h"
+#include "glitzint.h"
+
+#include "glitz-glx.h"
+
+#include <GL/gl.h>
+#include <GL/glx.h>
+
+#include "glitz_glxext.h"
+
+#define GLITZ_GLX_FEATURE_FBCONFIG_MASK            (1L << 0)
+#define GLITZ_GLX_FEATURE_PBUFFER_MASK             (1L << 1)
+#define GLITZ_GLX_FEATURE_MAKE_CURRENT_READ_MASK   (1L << 2)
+#define GLITZ_GLX_FEATURE_GET_PROC_ADDRESS_MASK    (1L << 3)
+#define GLITZ_GLX_FEATURE_MULTISAMPLE_MASK         (1L << 4)
+#define GLITZ_GLX_FEATURE_PBUFFER_MULTISAMPLE_MASK (1L << 5)
+
+typedef struct _glitz_glx_drawable glitz_glx_drawable_t;
+typedef struct _glitz_glx_screen_info_t glitz_glx_screen_info_t;
+typedef struct _glitz_glx_display_info_t glitz_glx_display_info_t;
+
+typedef struct _glitz_glx_static_proc_address_list_t {
+  glitz_glx_get_proc_address_t         get_proc_address;
+  glitz_glx_get_fbconfigs_t            get_fbconfigs;
+  glitz_glx_get_fbconfig_attrib_t      get_fbconfig_attrib;
+  glitz_glx_get_visual_from_fbconfig_t get_visual_from_fbconfig;
+  glitz_glx_create_pbuffer_t           create_pbuffer;
+  glitz_glx_destroy_pbuffer_t          destroy_pbuffer;
+  glitz_glx_query_drawable_t           query_drawable;
+  glitz_glx_make_context_current_t     make_context_current;
+  glitz_glx_create_new_context_t       create_new_context;
+} glitz_glx_static_proc_address_list_t;
+
+typedef struct _glitz_glx_thread_info_t {
+  glitz_glx_display_info_t **displays;
+  int                      n_displays;
+  char                     *gl_library;
+  void                     *dlhand;
+} glitz_glx_thread_info_t;
+
+struct _glitz_glx_display_info_t {
+  glitz_glx_thread_info_t *thread_info;
+  Display                 *display;
+  glitz_glx_screen_info_t **screens;
+  int n_screens;
+};
+
+typedef struct _glitz_glx_context_info_t {
+  glitz_glx_drawable_t *drawable;
+  glitz_surface_t      *surface;
+  glitz_constraint_t   constraint;
+} glitz_glx_context_info_t;
+
+typedef struct _glitz_glx_context_t {
+  GLXContext        context;
+  glitz_format_id_t id;
+  GLXFBConfig       fbconfig;
+  glitz_backend_t   backend;
+  glitz_gl_int_t    max_viewport_dims[2];
+  glitz_gl_int_t    max_texture_2d_size;
+  glitz_gl_int_t    max_texture_rect_size;
+  glitz_bool_t      initialized;
+} glitz_glx_context_t;
+
+struct _glitz_glx_screen_info_t {
+  glitz_glx_display_info_t             *display_info;
+  int                                  screen;
+  int                                  drawables;
+  glitz_drawable_format_t              *formats;
+  XID                                  *format_ids;
+  int                                  n_formats;  
+  glitz_glx_context_t                  **contexts;
+  int                                  n_contexts;
+  glitz_glx_context_info_t             context_stack[GLITZ_CONTEXT_STACK_SIZE];
+  int                                  context_stack_size;
+  GLXContext                           root_context;
+  unsigned long                        glx_feature_mask;
+  glitz_gl_float_t                     glx_version;
+  glitz_glx_static_proc_address_list_t glx;
+  glitz_program_map_t                  program_map;
+};
+
+struct _glitz_glx_drawable {
+  glitz_drawable_t        base;
+  
+  glitz_glx_screen_info_t *screen_info;
+  glitz_glx_context_t     *context;
+  GLXDrawable             drawable;
+  GLXDrawable             pbuffer;
+};
+
+extern void __internal_linkage
+glitz_glx_query_extensions (glitz_glx_screen_info_t *screen_info,
+                            glitz_gl_float_t        glx_version);
+
+extern glitz_glx_screen_info_t *__internal_linkage
+glitz_glx_screen_info_get (Display *display,
+                           int     screen);
+
+extern glitz_function_pointer_t __internal_linkage
+glitz_glx_get_proc_address (const char *name,
+                            void       *closure);
+
+extern glitz_glx_context_t *__internal_linkage
+glitz_glx_context_get (glitz_glx_screen_info_t *screen_info,
+                       glitz_drawable_format_t *format);
+
+extern void __internal_linkage
+glitz_glx_context_destroy (glitz_glx_screen_info_t *screen_info,
+                           glitz_glx_context_t     *context);
+
+extern void __internal_linkage
+glitz_glx_query_formats (glitz_glx_screen_info_t *screen_info);
+
+extern GLXPbuffer __internal_linkage
+glitz_glx_pbuffer_create (glitz_glx_screen_info_t    *screen_info,
+                          GLXFBConfig                fbconfig,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask,
+                          unsigned int               *width,
+                          unsigned int               *height);
+
+extern void __internal_linkage
+glitz_glx_pbuffer_destroy (glitz_glx_screen_info_t *screen_info,
+                           GLXPbuffer              pbuffer);
+
+extern glitz_drawable_t *__internal_linkage
+glitz_glx_create_pbuffer (void                       *abstract_templ,
+                          glitz_drawable_format_t    *format,
+                          glitz_pbuffer_attributes_t *attributes,
+                          unsigned long              mask);
+
+extern void __internal_linkage
+glitz_glx_push_current (void               *abstract_drawable,
+                        glitz_surface_t    *surface,
+                        glitz_constraint_t constraint);
+
+extern glitz_surface_t * __internal_linkage
+glitz_glx_pop_current (void *abstract_drawable);
+
+extern glitz_status_t __internal_linkage
+glitz_glx_make_current_read (void *abstract_surface);
+
+extern void __internal_linkage
+glitz_glx_destroy (void *abstract_drawable);
+
+extern void __internal_linkage
+glitz_glx_swap_buffers (void *abstract_drawable);
+
+/* Avoid unnecessary PLT entries.  */
+
+slim_hidden_proto(glitz_glx_init)
+slim_hidden_proto(glitz_glx_fini)
+slim_hidden_proto(glitz_glx_find_drawable_format)
+slim_hidden_proto(glitz_glx_get_visual_info_from_format)
+slim_hidden_proto(glitz_glx_create_drawable_for_window)
+slim_hidden_proto(glitz_glx_create_pbuffer_drawable)
+
+#endif /* GLITZ_GLXINT_H_INCLUDED */