Remove xcl and CVSROOT.

12 files changed, 1638 insertions, 0 deletions

diff --git a/.cvsignore b/.cvsignore
new file mode 100644
index 0000000..ed2f649
--- /dev/null
+++ b/.cvsignore
@@ -0,0 +1,14 @@
+Makefile
+Makefile.in
+aclocal.m4
+autom4te.cache
+config.guess
+config.log
+config.status
+config.sub
+configure
+depcomp
+install-sh
+libtool
+ltmain.sh
+missing
diff --git a/Doxyfile b/Doxyfile
new file mode 100644
index 0000000..b915677
--- /dev/null
+++ b/Doxyfile
@@ -0,0 +1,139 @@
+PROJECT_NAME           = XCB Utility
+PROJECT_NUMBER         =
+OUTPUT_DIRECTORY       = doc/
+INPUT                  = xcb_util_intro image/
+IMAGE_PATH             = doc/img
+OUTPUT_LANGUAGE        = English
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+ENUM_VALUES_PER_LINE   = 1
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = NO
+HIDE_UNDOC_MEMBERS     = YES
+HIDE_UNDOC_CLASSES     = YES
+HIDE_FRIEND_COMPOUNDS  = YES
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = 
+INTERNAL_DOCS          = NO
+STRIP_CODE_COMMENTS    = YES
+CASE_SENSE_NAMES       = YES
+SHORT_NAMES            = NO
+HIDE_SCOPE_NAMES       = NO
+VERBATIM_HEADERS       = NO
+SHOW_INCLUDE_FILES     = NO
+JAVADOC_AUTOBRIEF      = YES
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = NO
+INHERIT_DOCS           = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 2
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ALIASES                = 
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = NO
+SHOW_USED_FILES        = NO
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+FILE_PATTERNS          =
+RECURSIVE              = NO
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = NO
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 2
+IGNORE_PREFIX          = 
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+GENERATE_LATEX         = YES
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+GENERATE_MAN           = YES
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = YES
+GENERATE_XML           = YES
+XML_SCHEMA             = 
+XML_DTD                = 
+GENERATE_AUTOGEN_DEF   = NO
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = NO
+INCLUDE_PATH           =
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+CLASS_DIAGRAMS         = NO
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = NO
+CLASS_GRAPH            = NO
+COLLABORATION_GRAPH    = NO
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = NO
+INCLUDED_BY_GRAPH      = NO
+GRAPHICAL_HIERARCHY    = NO
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 512
+MAX_DOT_GRAPH_HEIGHT   = 512
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+SEARCHENGINE           = NO
diff --git a/autogen.sh b/autogen.sh
new file mode 100755
index 0000000..d68a142
--- /dev/null
+++ b/autogen.sh
@@ -0,0 +1,3 @@
+#! /bin/sh
+autoreconf -v --install || exit 1
+./configure "$@"
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..4f5bbd7
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,33 @@
+AC_PREREQ(2.57)
+AC_INIT([xcb-util],0.1,[jamey@minilop.net])
+AC_CONFIG_SRCDIR([Makefile.am])
+AM_INIT_AUTOMAKE([foreign dist-bzip2])
+
+AC_CHECK_PROGS(M4, m4)
+AC_CHECK_PROGS(GPERF, gperf, [no])
+if test $GPERF = "no"; then
+	AC_MSG_ERROR([Can't find gperf, please install it and try again])
+fi
+AC_PROG_CC
+AC_PROG_LIBTOOL
+
+xcbincludedir='${includedir}/X11/XCB'
+AC_SUBST(xcbincludedir)
+
+pkgconfigdir='${libdir}/pkgconfig'
+AC_SUBST(pkgconfigdir)
+
+PKG_CHECK_MODULES(XCB, xcb)
+
+AC_OUTPUT([Makefile
+	convenient/Makefile convenient/xcb-aux.pc
+	reply/Makefile reply/xcb-reply.pc
+	image/Makefile image/xcb-image.pc
+	atom/Makefile atom/xcb-atom.pc
+	event/Makefile event/xcb-event.pc
+	keysyms/Makefile keysyms/xcb-keysyms.pc
+	property/Makefile property/xcb-property.pc
+	icccm/Makefile icccm/xcb-icccm.pc
+	wm/Makefile wm/xcb-wm.pc
+	xcb_util_intro
+	])
diff --git a/image/.cvsignore b/image/.cvsignore
new file mode 100644
index 0000000..586d052
--- /dev/null
+++ b/image/.cvsignore
@@ -0,0 +1,10 @@
+.deps
+.libs
+Makefile.in
+Makefile
+*.lo
+*.loT
+*.la
+test_xcb_image
+test_xcb_image_shm
+*.pc
diff --git a/image/Makefile.am b/image/Makefile.am
new file mode 100644
index 0000000..738949d
--- /dev/null
+++ b/image/Makefile.am
@@ -0,0 +1,24 @@
+
+MAINTAINERCLEANFILES = Makefile.in
+
+lib_LTLIBRARIES = libXCBImage.la
+
+xcbinclude_HEADERS = xcb_image.h
+
+AM_CFLAGS = -Wall
+INCLUDES = $(XCB_CFLAGS) -I../convenient
+LDADD = $(XCB_LIBS) -L../convenient -lXCBAux
+
+libXCBImage_la_SOURCES = xcb_image.c
+
+pkgconfig_DATA = xcb-image.pc
+
+EXTRA_DIST=xcb-image.pc.in
+
+noinst_PROGRAMS = test_xcb_image test_xcb_image_shm
+
+test_xcb_image_LDADD = $(LDADD) -L. -lXCBImage
+test_xcb_image_SOURCES = test_xcb_image.c
+
+test_xcb_image_shm_LDADD = $(LDADD) -L. -lXCBImage
+test_xcb_image_shm_SOURCES = test_xcb_image_shm.c
diff --git a/image/test_xcb_image.c b/image/test_xcb_image.c
new file mode 100644
index 0000000..726c3fa
--- /dev/null
+++ b/image/test_xcb_image.c
@@ -0,0 +1,231 @@
+/* gcc -g -O2 -Wall `pkg-config --cflags --libs xcb` -o test xcb_image.o test_xcb_image.c */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <X11/XCB/xcb.h>
+#include <X11/XCB/shm.h>
+#include <X11/Xlib.h>
+
+#include "xcb_aux.h"
+#include "xcb_image.h"
+
+#define W_W 4
+#define W_H 4
+
+void
+reflect_window (XCBConnection *c,
+		XCBDRAWABLE win,
+		XCBDRAWABLE new_win,
+		XCBGCONTEXT gc,
+		CARD16      width,
+		CARD16      height)
+{
+  XCBImage *image;
+  CARD32    pixel1;
+  CARD32    pixel2;
+  INT32     left_x;
+  INT32     right_x;
+  INT32     y;
+
+  int i, j;
+  int format;
+
+  format = ZPixmap;
+
+  printf ("get_image %d %d\n", width, height);
+  image = XCBImageGet (c, win,
+			 0, 0, width, height,
+			 AllPlanes,
+			 format);
+
+  printf ("Create image summary:\n");
+  printf (" * format..........: %d\n", image->format);
+  printf (" * byte order......: %d\n", image->image_byte_order);
+  printf (" * bitmap unit.....: %d\n", image->bitmap_format_scanline_unit);
+  printf (" * bitmap order....: %d\n", image->bitmap_format_bit_order);
+  printf (" * bitmap pad......: %d\n", image->bitmap_format_scanline_pad);
+  printf (" * depth...........: %d\n", image->depth);
+  printf (" * bytes/line......: %ld\n", image->bytes_per_line);
+  printf (" * bits/pixel......: %d\n", image->bits_per_pixel);
+
+  printf ("bpl %ld %d\n", image->bytes_per_line, image->height);
+
+  for (j = 0 ; j < image->height ; j++)
+    {
+      for (i = 0 ; i < image->width ; i++)
+	{
+	  pixel1 = XCBImageGetPixel (image, i, j);
+	  printf ("%6ld ", pixel1);
+	}
+      printf ("\n");
+    }
+
+  printf("calculating reflection -- this may take awhile...\n");
+  
+  for (left_x = 0 ; left_x < width/2 ; left_x++)
+    {
+      for (y = 0 ; y < height ; y++)
+	{
+	  pixel1 = XCBImageGetPixel (image, left_x, y);
+	  right_x = width - left_x-1;
+	  if (left_x != right_x)
+	    {
+	      pixel2 = XCBImageGetPixel (image, right_x, y);
+	      XCBImagePutPixel (image, left_x, y, pixel2);
+	    }
+	  XCBImagePutPixel (image, right_x, y, pixel1);
+	}
+      printf ("\n");
+    }
+  printf("putting image\n");
+  for (j = 0 ; j < image->height ; j++)
+    {
+      for (i = 0 ; i < image->width ; i++)
+	{
+	  pixel1 = XCBImageGetPixel (image, i, j);
+	  printf ("%6ld ", pixel1);
+	}
+      printf ("\n");
+    }
+  XCBImagePut (c, new_win, gc, image,
+		 0, 0, 0, 0, width, height);
+  image = XCBImageGet (c, new_win,
+			 0, 0, width, height,
+			 AllPlanes,
+			 format);
+  printf ("New : \n");
+  for (j = 0 ; j < image->height ; j++)
+    {
+      for (i = 0 ; i < image->width ; i++)
+	{
+	  pixel1 = XCBImageGetPixel (image, i, j);
+	  printf ("%6ld ", pixel1);
+	}
+      printf ("\n");
+    }
+  printf ("done\n");
+}
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection   *c;
+  XCBSCREEN       *screen;
+  XCBDRAWABLE      win;
+  XCBDRAWABLE      new_win;
+  XCBDRAWABLE      rect;
+  XCBRECTANGLE     rect_coord = { 0, 0, W_W, W_H};
+  XCBGCONTEXT      bgcolor, fgcolor;
+  XCBPOINT         points[2];
+  CARD32           mask;
+  CARD32           valgc[2];
+  CARD32           valwin[3];
+  int              depth;
+  int              screen_nbr;
+  XCBGenericEvent *e;
+  
+  /* Open the connexion to the X server and get the first screen */
+  c = XCBConnect (NULL, &screen_nbr);
+  screen = XCBAuxGetScreen (c, screen_nbr);
+  depth = XCBAuxGetDepth (c, screen);
+
+  /* Create a black graphic context for drawing in the foreground */
+  win.window = screen->root;
+
+  fgcolor = XCBGCONTEXTNew(c);
+  mask = GCForeground | GCGraphicsExposures;
+  valgc[0] = screen->black_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  XCBCreateGC(c, fgcolor, win, mask, valgc);
+
+  bgcolor = XCBGCONTEXTNew(c);
+  mask = GCForeground | GCGraphicsExposures;
+  valgc[0] = screen->white_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  XCBCreateGC(c, bgcolor, win, mask, valgc);
+
+  /* Ask for our window's Id */
+  win.window = XCBWINDOWNew(c);
+
+  /* Create the window */
+  mask = XCBCWBackPixel | XCBCWEventMask | XCBCWDontPropagate;
+  valwin[0] = screen->white_pixel;
+  valwin[1] = KeyPressMask | ButtonReleaseMask | ExposureMask;
+  valwin[2] = ButtonPressMask;
+  XCBCreateWindow (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win.window,               /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   W_W, W_H,                 /* width, height       */
+		   10,                       /* border_width        */
+		   InputOutput,              /* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, valwin);                 /* masks, not used yet */
+
+  /* Map the window on the screen */
+  XCBMapWindow (c, win.window);
+
+  /* Create a Pixmap that will fill the window */
+  rect.pixmap = XCBPIXMAPNew (c);
+  XCBCreatePixmap(c, depth, rect.pixmap, win, W_W, W_H);
+  XCBPolyFillRectangle(c, rect, bgcolor, 1, &rect_coord);
+  points[0].x = 0;
+  points[0].y = 0;
+  points[1].x = 1;
+  points[1].y = 1;
+  XCBPolyLine(c, CoordModeOrigin, rect, fgcolor, 2, points);
+/*   points[0].x = 10; */
+/*   points[0].y = 10; */
+/*   points[1].x = 10; */
+/*   points[1].y = 40; */
+/*   XCBPolyLine(c, CoordModeOrigin, rect, fgcolor, 2, points); */
+
+  /* Ask for our window's Id */
+  new_win.window = XCBWINDOWNew(c);
+
+  /* Create the window */
+  mask = XCBCWBackPixel | XCBCWEventMask | XCBCWDontPropagate;
+  valwin[0] = screen->white_pixel;
+  valwin[1] = KeyPressMask | ButtonReleaseMask | ExposureMask;
+  valwin[2] = ButtonPressMask;
+  XCBCreateWindow (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   new_win.window,               /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   W_W, W_H,                 /* width, height       */
+		   10,                       /* border_width        */
+		   InputOutput,              /* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, valwin);                 /* masks, not used yet */
+
+  
+
+  /* Map the window on the screen */
+  XCBMapWindow (c, new_win.window);
+
+
+  XCBSync (c, 0); 
+
+  while ((e = XCBWaitForEvent(c)))
+    {
+      switch (e->response_type)
+	{ 
+	case XCBExpose:
+	  {
+	    XCBCopyArea(c, rect, win, bgcolor,
+			0, 0, 0, 0, W_W, W_H);
+	    reflect_window (c, win, new_win,
+			    fgcolor,
+			    W_W, W_H);
+	    XCBSync (c, 0);
+	    break;
+	  }
+	}
+      free (e);
+    }
+
+  return 1;
+}
diff --git a/image/test_xcb_image_shm.c b/image/test_xcb_image_shm.c
new file mode 100644
index 0000000..4975fe5
--- /dev/null
+++ b/image/test_xcb_image_shm.c
@@ -0,0 +1,167 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#include <X11/XCB/xcb.h>
+#include <X11/XCB/shm.h>
+#include <X11/Xlib.h>
+
+#include "xcb_aux.h"
+#include "xcb_image.h"
+
+#define W_W 40
+#define W_H 40
+
+
+
+int
+main (int argc, char *argv[])
+{
+  XCBConnection   *c;
+  XCBSCREEN       *screen;
+  XCBDRAWABLE      win;
+  XCBDRAWABLE      rect;
+  XCBRECTANGLE     rect_coord = { 0, 0, W_W, W_H};
+  XCBGCONTEXT      bgcolor, fgcolor;
+  XCBPOINT         points[2];
+  CARD32           mask;
+  CARD32           valgc[2];
+  CARD32           valwin[3];
+  int              depth;
+  int              screen_nbr;
+  XCBGenericEvent *e;
+  
+  /* Open the connexion to the X server and get the first screen */
+  c = XCBConnect (NULL, &screen_nbr);
+  screen = XCBAuxGetScreen (c, screen_nbr);
+  depth = XCBAuxGetDepth (c, screen);
+
+  /* Create a black graphic context for drawing in the foreground */
+  win.window = screen->root;
+
+  fgcolor = XCBGCONTEXTNew(c);
+  mask = GCForeground | GCGraphicsExposures;
+  valgc[0] = screen->black_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  XCBCreateGC(c, fgcolor, win, mask, valgc);
+
+  bgcolor = XCBGCONTEXTNew(c);
+  mask = GCForeground | GCGraphicsExposures;
+  valgc[0] = screen->white_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  XCBCreateGC(c, bgcolor, win, mask, valgc);
+
+  /* Shm test */
+  printf ("shm test begin\n");
+  XCBImage *img = 0;
+  XCBShmQueryVersionRep *rep;
+  XCBShmSegmentInfo shminfo;
+
+  rep = XCBShmQueryVersionReply (c,
+				 XCBShmQueryVersion (c),
+				 NULL);
+  if (rep)
+    {
+      CARD8 format;
+      
+      if (rep->shared_pixmaps && 
+	  (rep->major_version > 1 || rep->minor_version > 0))
+	format = rep->pixmap_format;
+      else
+	format = 0;
+      img = XCBImageSHMCreate (c, depth, format, NULL, W_W, W_H);
+
+      printf ("Create image summary:\n");
+      printf (" * format..........: %d\n", img->format);
+      printf (" * byte order......: %d\n", img->image_byte_order);
+      printf (" * bitmap unit.....: %d\n", img->bitmap_format_scanline_unit);
+      printf (" * bitmap order....: %d\n", img->bitmap_format_bit_order);
+      printf (" * bitmap pad......: %d\n", img->bitmap_format_scanline_pad);
+
+      shminfo.shmid = shmget (IPC_PRIVATE,
+			      img->bytes_per_line*img->height,
+			      IPC_CREAT|0777);
+      shminfo.shmaddr = shmat(shminfo.shmid, 0, 0);
+      img->data = shminfo.shmaddr;
+
+      shminfo.shmseg = XCBShmSEGNew (c);
+      XCBShmAttach(c, shminfo.shmseg,
+		   shminfo.shmid, 0);
+      shmctl(shminfo.shmid, IPC_RMID, 0);
+    }
+
+  if (!img)
+    {
+      printf ("Can't use shm...\n");
+      exit (0);
+    }
+
+  /* Draw in the image */
+  printf ("put the pixel\n");
+  XCBImagePutPixel (img, 20, 20, 65535);
+  printf ("fin put pixel\n");
+
+  /* Ask for our window's Id */
+  win.window = XCBWINDOWNew(c);
+
+  /* Create the window */
+  mask = XCBCWBackPixel | XCBCWEventMask | XCBCWDontPropagate;
+  valwin[0] = screen->white_pixel;
+  valwin[1] = KeyPressMask | ButtonReleaseMask | ExposureMask;
+  valwin[2] = ButtonPressMask;
+  XCBCreateWindow (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win.window,               /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   W_W, W_H,                 /* width, height       */
+		   10,                       /* border_width        */
+		   InputOutput,              /* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, valwin);                 /* masks, not used yet */
+
+  /* Map the window on the screen */
+  XCBMapWindow (c, win.window);
+
+  /* Create a Pixmap that will fill the window */
+  rect.pixmap = XCBPIXMAPNew (c);
+  XCBCreatePixmap(c, depth, rect.pixmap, win, W_W, W_H);
+  XCBPolyFillRectangle(c, rect, bgcolor, 1, &rect_coord);
+  points[0].x = 0;
+  points[0].y = 0;
+  points[1].x = 1;
+  points[1].y = 1;
+  XCBPolyLine(c, CoordModeOrigin, rect, fgcolor, 2, points);
+/*   points[0].x = 10; */
+/*   points[0].y = 10; */
+/*   points[1].x = 10; */
+/*   points[1].y = 40; */
+/*   XCBPolyLine(c, CoordModeOrigin, rect, fgcolor, 2, points); */
+
+
+  XCBSync (c, 0); 
+
+  while ((e = XCBWaitForEvent(c)))
+    {
+      switch (e->response_type)
+	{ 
+	case XCBExpose:
+	  {
+	    XCBCopyArea(c, rect, win, bgcolor,
+			0, 0, 0, 0, W_W, W_H);
+	    printf ("put image\n");
+	    XCBImageSHMPut (c, win, fgcolor,
+			       img, shminfo,
+			       0, 0, 0, 0, W_W,W_H,
+			       0);
+	    XCBSync (c, 0);
+	    break;
+	  }
+	}
+      free (e);
+    }
+
+  return 1;
+}
diff --git a/image/xcb-image.pc.in b/image/xcb-image.pc.in
new file mode 100644
index 0000000..8f7771c
--- /dev/null
+++ b/image/xcb-image.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: XCBImage
+Description: XCB image convenience library
+Version: @PACKAGE_VERSION@
+Requires: xcb
+Libs: -L${libdir} -lXCBImage @LIBS@
+Cflags: -I${includedir}
diff --git a/image/xcb_image.c b/image/xcb_image.c
new file mode 100644
index 0000000..ec0f8e1
--- /dev/null
+++ b/image/xcb_image.c
@@ -0,0 +1,624 @@
+/* gcc -g -O2 -Wall -c `pkg-config --cflags xcb` -o xcb_image.o xcb_image.c */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <X11/XCB/xcb.h>
+#include <X11/XCB/shm.h>
+
+#include "xcb_image.h"
+
+/* Convenient */
+static CARD8          xcb_bits_per_pixel   (XCBConnection *c, CARD8 depth);
+static CARD32         xcb_bytes_per_line   (CARD8 pad, CARD16 width, CARD8 bpp);
+static CARD8          xcb_scanline_pad_get (XCBConnection *conn,
+					    CARD8          depth);
+
+static inline CARD32 _lomask(int n)
+{
+  return (1 << n) - 1;
+}
+
+static unsigned int Ones(                /* HACKMEM 169 */
+    CARD32 mask)
+{
+    register CARD32 y;
+
+    y = (mask >> 1) &033333333333;
+    y = mask - y - ((y >>1) & 033333333333);
+    return ((unsigned int) (((y + (y >> 3)) & 030707070707) % 077));
+}
+
+
+/* Convenient functions */
+
+static CARD8
+xcb_bits_per_pixel (XCBConnection *c, CARD8 depth)
+{ 
+  XCBFORMAT *fmt = XCBConnSetupSuccessRepPixmapFormats(XCBGetSetup(c));
+  XCBFORMAT *fmtend = fmt + XCBConnSetupSuccessRepPixmapFormatsLength(XCBGetSetup(c));
+  
+  for(; fmt != fmtend; ++fmt)
+    if(fmt->depth == depth)
+      return fmt->bits_per_pixel;
+  
+  if(depth <= 4)
+    return 4;
+  if(depth <= 8)
+    return 8;
+  if(depth <= 16)
+    return 16;
+  return 32;
+}
+
+static CARD32
+xcb_bytes_per_line (CARD8 pad, CARD16 width, CARD8 bpp)
+{
+  return ((bpp * width + pad - 1) & -pad) >> 3;
+}
+
+static CARD8
+xcb_scanline_pad_get (XCBConnection *conn,
+		      CARD8          depth)
+{
+  XCBFORMAT *fmt = XCBConnSetupSuccessRepPixmapFormats(XCBGetSetup(conn));
+  XCBFORMAT *fmtend = fmt + XCBConnSetupSuccessRepPixmapFormatsLength(XCBGetSetup(conn));
+  
+  for(; fmt != fmtend; ++fmt)
+    if(fmt->depth == depth)
+      {
+	return fmt->scanline_pad;
+      }
+
+  return XCBGetSetup (conn)->bitmap_format_scanline_pad;
+
+/*   XCBFORMATIter iter; */
+/*   int           cur; */
+
+/*   iter =  XCBConnSetupSuccessRepPixmapFormatsIter (conn->setup); */
+/*   for (cur = 0 ; cur < iter.rem ; cur++, XCBFORMATNext (&iter)) */
+/*     if (iter.data->depth == depth) */
+/*       return iter.data->scanline_pad; */
+  
+/*   return XCBGetSetup (conn)->bitmap_format_scanline_pad; */
+}
+
+
+XCBImage *
+XCBImageCreate (XCBConnection *conn,
+		CARD8          depth,
+		CARD8          format,
+		unsigned int   offset,
+		BYTE          *data,
+		CARD16         width,
+		CARD16         height,
+		CARD8          xpad,
+		CARD32         bytes_per_line)
+{
+  XCBImage               *image;
+  XCBConnSetupSuccessRep *rep;
+  CARD8                   bpp = 1; /* bits per pixel */
+
+  if (depth == 0 || depth > 32 ||
+      (format != XYBitmap && format != XYPixmap && format != ZPixmap) ||
+      (format == XYBitmap && depth != 1) ||
+      (xpad != 8 && xpad != 16 && xpad != 32))
+    return (XCBImage *) NULL;
+
+  image = (XCBImage *)malloc (sizeof (XCBImage));
+  if (image == NULL)
+    return NULL;
+  
+  rep = XCBGetSetup (conn);
+
+  image->width = width;
+  image->height = height;
+  image->format = format;
+  image->image_byte_order = rep->image_byte_order;
+  image->bitmap_format_scanline_unit = rep->bitmap_format_scanline_unit;
+  image->bitmap_format_bit_order = rep->bitmap_format_bit_order;
+  image->bitmap_format_scanline_pad = xpad;
+  
+  if (format == ZPixmap) 
+    {
+      bpp = xcb_bits_per_pixel (conn, depth);
+    }
+
+  image->xoffset = offset;
+  image->depth = depth;
+  image->data = data;
+
+  /*
+   * compute per line accelerator.
+   */
+  if (bytes_per_line == 0)
+    {
+      if (format == ZPixmap)
+	image->bytes_per_line = 
+	  xcb_bytes_per_line (image->bitmap_format_scanline_pad,
+			      width, bpp);
+      else
+	image->bytes_per_line =
+	  xcb_bytes_per_line (image->bitmap_format_scanline_pad,
+			      width + offset, 1);
+    }
+  else
+    image->bytes_per_line = bytes_per_line;
+
+  image->bits_per_pixel = bpp;
+
+  return image;
+}
+
+int
+XCBImageInit (XCBImage *image)
+{
+  if ((image->depth == 0 || image->depth > 32) ||
+      (image->format != XYBitmap &&
+       image->format != XYPixmap &&
+       image->format != ZPixmap) ||
+      (image->format == XYBitmap && image->depth != 1) ||
+      (image->bitmap_format_scanline_pad != 8 &&
+       image->bitmap_format_scanline_pad != 16 &&
+       image->bitmap_format_scanline_pad != 32))
+    return 0;
+  
+  /*
+   * compute per line accelerator.
+   */
+  if (image->bytes_per_line == 0)
+    {
+      if (image->format == ZPixmap)
+	image->bytes_per_line = 
+	  xcb_bytes_per_line (image->bitmap_format_scanline_pad,
+			      image->width,
+			      image->bits_per_pixel);
+      else
+	image->bytes_per_line = 
+	  xcb_bytes_per_line (image->bitmap_format_scanline_pad,
+			      image->width + image->xoffset,
+			      1);
+    }
+  
+  return 1;
+}
+
+int
+XCBImageDestroy (XCBImage *image)
+{
+  if (image->data != NULL)
+    free (image->data);
+  free (image);
+
+  return 1;
+}
+
+XCBImage *
+XCBImageGet (XCBConnection *conn,
+	     XCBDRAWABLE    draw,
+	     INT16          x,
+	     INT16          y,
+	     CARD16         width,
+	     CARD16         height,
+	     CARD32         plane_mask,
+	     CARD8          format)
+{
+  XCBImage       *image;
+  XCBGetImageRep *rep;
+  BYTE           *data;
+
+  rep = XCBGetImageReply (conn, 
+			  XCBGetImage (conn,
+				       format,
+				       draw,
+				       x, y,
+				       width, height,
+				       plane_mask),
+			  NULL);
+  if (!rep)
+    return NULL;
+
+  data = malloc(XCBGetImageDataLength(rep));
+  if (!data)
+    return NULL;
+  memcpy(data, XCBGetImageData (rep), XCBGetImageDataLength (rep));
+
+  if (format == XYPixmap)
+    {
+      image = XCBImageCreate (conn,
+				Ones (plane_mask & _lomask(rep->depth)),
+				format,
+				0,
+				data,
+				width, height,
+				xcb_scanline_pad_get (conn, rep->depth),
+				0);
+    }
+  else /* format == ZPixmap */
+    {
+      image = XCBImageCreate (conn,
+				rep->depth,
+				ZPixmap,
+				0,
+				data,
+				width, height,
+				xcb_scanline_pad_get (conn, rep->depth),
+				0);
+    }
+  if (!image)
+    free (data);
+
+  free (rep);
+
+  return image;
+}
+
+int
+XCBImagePut (XCBConnection *conn,
+	     XCBDRAWABLE    draw,
+	     XCBGCONTEXT    gc,
+	     XCBImage      *image,
+	     INT16          x_offset,
+	     INT16          y_offset,
+	     INT16          x,
+	     INT16          y,
+	     CARD16         width,
+	     CARD16         height)
+{
+  INT32 w;
+  INT32 h;
+  int dest_bits_per_pixel;
+  int dest_scanline_pad;
+  int left_pad;
+
+  w = width;
+  h = height;
+
+  if (x_offset < 0)
+    {
+      w += x_offset;
+      x_offset = 0;
+    }
+
+  if (y_offset < 0)
+    {
+      h += y_offset;
+      y_offset = 0;
+    }
+
+  if ((w + x_offset) > image->width)
+    w = image->width - x_offset;
+
+  if ((h + y_offset) > image->height)
+    h = image->height - y_offset;
+
+  if ((w <= 0) || (h <= 0))
+    return 0;
+
+  if ((image->bits_per_pixel == 1) || (image->format != ZPixmap))
+    {
+      dest_bits_per_pixel = 1;
+      dest_scanline_pad = XCBGetSetup (conn)->bitmap_format_scanline_pad;
+      left_pad = image->xoffset & (XCBGetSetup (conn)->bitmap_format_scanline_unit- 1);
+    }
+  else
+    {
+      XCBFORMATIter iter;
+      
+      dest_bits_per_pixel = image->bits_per_pixel;
+      dest_scanline_pad = image->bitmap_format_scanline_pad;
+      left_pad = 0;
+      iter =  XCBConnSetupSuccessRepPixmapFormatsIter (XCBGetSetup (conn));
+      for (; iter.rem ; XCBFORMATNext (&iter))
+	if (iter.data->depth == image->depth)
+	  {
+	    dest_bits_per_pixel = iter.data->bits_per_pixel;
+	    dest_scanline_pad = iter.data->scanline_pad;
+	  }
+      
+      if (dest_bits_per_pixel != image->bits_per_pixel) {
+	XCBImage       img;
+	register INT32 i, j;
+	XCBConnSetupSuccessRep *rep;
+	
+	/* XXX slow, but works */
+	rep = XCBGetSetup (conn);
+	img.width = width;
+	img.height = height;
+	img.xoffset = 0;
+	img.format = ZPixmap;
+	img.image_byte_order = rep->image_byte_order;
+	img.bitmap_format_scanline_unit = rep->bitmap_format_scanline_unit;
+	img.bitmap_format_bit_order = rep->bitmap_format_bit_order;
+	img.bitmap_format_scanline_pad = dest_scanline_pad;
+	img.depth = image->depth;
+	img.bits_per_pixel = dest_bits_per_pixel;
+	img.bytes_per_line =  xcb_bytes_per_line (dest_scanline_pad,
+						  width,
+						  dest_bits_per_pixel);
+	img.data = malloc((CARD8) (img.bytes_per_line * height));
+	
+	if (img.data == NULL)
+	  return 0;
+	
+	for (j = height; --j >= 0; )
+	  for (i = width; --i >= 0; )
+	    XCBImagePutPixel(&img,
+				i, j,
+				XCBImageGetPixel(image,
+						    x_offset + i,
+						    y_offset + j));
+	
+	XCBPutImage(conn, img.format, draw, gc,
+		    w, h, x, y,
+		    dest_scanline_pad,
+		    img.depth,
+		    img.bytes_per_line * height,
+		    img.data);
+	
+	free(img.data);
+	return 0;
+      }
+    }
+
+  XCBPutImage(conn, image->format, draw, gc,
+	      w, h, x, y,
+	      left_pad,
+	      image->depth, image->bytes_per_line * height,
+	      image->data);
+
+  return 0;
+}
+
+/*
+ * Shm stuff
+ */
+
+XCBImage *
+XCBImageSHMCreate (XCBConnection *conn,
+		   CARD8          depth,
+		   CARD8          format,
+		   BYTE          *data,
+		   CARD16         width,
+		   CARD16         height)
+{
+  XCBImage               *image;
+  XCBConnSetupSuccessRep *rep;
+
+  image = (XCBImage *)malloc (sizeof (XCBImage));
+  if (!image)
+    return NULL;
+  
+  rep = XCBGetSetup (conn);
+  
+  image->width = width;
+  image->height = height;
+  image->xoffset = 0;
+  image->format = format;
+  image->data = data;
+  image->depth = depth;
+
+  image->image_byte_order = rep->image_byte_order;
+  image->bitmap_format_scanline_unit = rep->bitmap_format_scanline_unit;
+  image->bitmap_format_bit_order = rep->bitmap_format_bit_order;
+  image->bitmap_format_scanline_pad = xcb_scanline_pad_get (conn, depth);
+
+  if (format == ZPixmap)
+    image->bits_per_pixel = xcb_bits_per_pixel (conn, depth);
+  else
+    image->bits_per_pixel = 1;
+
+  image->bytes_per_line = xcb_bytes_per_line (image->bitmap_format_scanline_pad,
+					      width,
+					      image->bits_per_pixel);
+
+  return image;
+}
+
+int
+XCBImageSHMDestroy (XCBImage *image)
+{
+  if (image)
+    free (image);
+  
+  return 1;
+}
+
+int
+XCBImageSHMPut (XCBConnection *conn,
+		XCBDRAWABLE    draw,
+		XCBGCONTEXT    gc,
+		XCBImage      *image,
+		XCBShmSegmentInfo shminfo,
+		INT16          src_x,
+		INT16          src_y,
+		INT16          dest_x,
+		INT16          dest_y,
+		CARD16         src_width,
+		CARD16         src_height,
+		CARD8          send_event)
+{
+  if (!shminfo.shmaddr)
+    return 0;
+
+  XCBShmPutImage(conn, draw, gc,
+		 image->width, image->height,
+		 src_x, src_y, src_width, src_height,
+		 dest_x, dest_y,
+		 image->depth, image->format,
+		 send_event, 
+		 shminfo.shmseg,
+		 image->data - shminfo.shmaddr);
+  return 1;
+}
+
+int
+XCBImageSHMGet (XCBConnection *conn,
+		XCBDRAWABLE    draw,
+		XCBImage      *image,
+		XCBShmSegmentInfo shminfo,
+		INT16          x,
+		INT16          y,
+		CARD32         plane_mask)
+{
+  XCBShmGetImageRep *rep;
+  XCBShmGetImageCookie cookie;
+
+  if (!shminfo.shmaddr)
+    return 0;
+
+  cookie = XCBShmGetImage(conn, draw,
+			  x, y,
+			  image->width, image->height,
+			  plane_mask,
+			  image->format,
+			  shminfo.shmseg,
+			  image->data - shminfo.shmaddr);
+  rep = XCBShmGetImageReply(conn, cookie, NULL);
+  /* rep would be useful to get the visual id */
+  /* but i don't use it */
+  /* So, should we remove it ? */
+  
+  return 1;
+}
+
+/* GetPixel/PutPixel */
+
+static inline int XYINDEX (int x, XCBImage *img, int *bitp)
+{
+  int mask = img->bitmap_format_scanline_unit - 1;
+  int unit = (x + img->xoffset) & ~mask;
+  int byte = (x + img->xoffset) & mask;
+  if (img->bitmap_format_bit_order == MSBFirst)
+    byte = img->bitmap_format_scanline_unit - byte;
+  *bitp = byte & 7;
+  if (img->image_byte_order == MSBFirst)
+    byte = img->bitmap_format_scanline_unit - byte;
+  return (unit + byte) >> 3;
+}
+
+static inline int ZINDEX (int x, XCBImage *img)
+{
+  return (x * img->bits_per_pixel) >> 3;
+}
+
+static inline void set_bit (CARD8 *byte, int bit, int value)
+{
+  if (value)
+    *byte |= 1 << bit;
+  else
+    *byte &= ~(1 << bit);
+}
+
+int
+XCBImagePutPixel (XCBImage *image, int x, int y, CARD32 pixel)
+{
+  register BYTE *src = image->data + (y * image->bytes_per_line);
+
+  if (image->format == XYPixmap || (image->bits_per_pixel | image->depth) == 1)
+    {
+      int plane, bit;
+      /* do least signif plane 1st */
+      src += XYINDEX(x, image, &bit) + image->bytes_per_line * image->height * image->depth;
+      for (plane = image->depth; --plane >= 0; pixel >>= 1)
+	{
+	  src -= image->bytes_per_line * image->height;
+	  set_bit (src, bit, pixel & 1);
+	}
+    }
+  else
+    if (image->format == ZPixmap)
+      {
+	src += ZINDEX(x, image);
+	if (image->bits_per_pixel == 4)
+	{
+	  CARD8 mask = ~_lomask(4);
+	  pixel &= _lomask(image->depth);
+	  /* if x is odd and byte order is LSB, or
+	   * if x is even and byte order is MSB, then
+	   * want high nibble; else want low nibble. */
+	  if ((x & 1) == (image->image_byte_order == LSBFirst))
+	  {
+	    mask = ~mask;
+	    pixel <<= 4;
+	  }
+	  *src = (*src & mask) | pixel;
+	}
+	else
+	{
+	  int nbytes = image->bits_per_pixel >> 3;
+	  int rev = image->image_byte_order == MSBFirst;
+	  if(rev)
+	    src += nbytes - 1;
+	  while (--nbytes >= 0)
+	    {
+	      *src = pixel;
+	      pixel >>= 8;
+	      if(rev)
+		--src;
+	      else
+		++src;
+	    }
+	}
+      }
+    else
+      {
+	return 0; /* bad image */
+      }
+  return 1;
+}
+
+CARD32
+XCBImageGetPixel (XCBImage *image, int x, int y)
+{
+  CARD32         pixel = 0;
+  register BYTE *src = image->data + (y * image->bytes_per_line);
+  
+  if (image->format == XYPixmap || (image->bits_per_pixel | image->depth) == 1)
+    {
+      int plane, bit;
+      src += XYINDEX(x, image, &bit);
+      for (plane = image->depth; --plane >= 0; )
+	{
+	  pixel <<= 1;
+	  pixel |= (*src >> bit) & 1;
+	  src += image->bytes_per_line * image->height;
+	}
+    }
+  else
+    if (image->format == ZPixmap)
+      {
+	src += ZINDEX(x, image);
+	if (image->bits_per_pixel == 4)
+	{
+	  pixel = *src;
+	  /* if x is odd and byte order is LSB, or
+	   * if x is even and byte order is MSB, then
+	   * want high nibble; else want low nibble. */
+	  if ((x & 1) == (image->image_byte_order == LSBFirst))
+	    pixel >>= 4;
+	}
+	else
+	{
+	  int nbytes = image->bits_per_pixel >> 3;
+	  int rev = image->image_byte_order == MSBFirst;
+	  if(rev)
+	    src += nbytes - 1;
+	  while (--nbytes >= 0)
+	    {
+	      pixel <<= 8;
+	      pixel = *src;
+	      if(rev)
+		--src;
+	      else
+		++src;
+	    }
+	}
+      }
+    else
+      {
+	return 0; /* bad image */
+      }
+  return pixel & _lomask(image->depth);
+}
diff --git a/image/xcb_image.h b/image/xcb_image.h
new file mode 100644
index 0000000..36d33a7
--- /dev/null
+++ b/image/xcb_image.h
@@ -0,0 +1,361 @@
+
+#ifndef __XCB_IMAGE_H__
+#define __XCB_IMAGE_H__
+
+
+/**
+ * @defgroup XCB_Image XCB Image Functions
+ *
+ * Functions used to create and manipulate images.
+ *
+ * @{
+ */
+
+
+typedef struct XCBImage_ XCBImage;
+
+/**
+ * @struct XCBImage
+ * A structure that describes an XCBImage.
+ */
+struct XCBImage_
+{
+  CARD16         width;
+  CARD16         height;
+  unsigned int   xoffset;
+  CARD8          format;
+  BYTE          *data;
+  CARD8          image_byte_order;
+  CARD8          bitmap_format_scanline_unit;
+  CARD8          bitmap_format_bit_order;
+  CARD8          bitmap_format_scanline_pad;
+  CARD8          depth;
+  CARD32         bytes_per_line;
+  CARD8          bits_per_pixel;
+};
+
+typedef struct XCBShmSegmentInfo_ XCBShmSegmentInfo;
+
+/**
+ * @struct XCBShmSegmentInfo
+ * A structure that stores the informations needed by the MIT Shm
+ * Extension.
+ */
+struct XCBShmSegmentInfo_
+{
+  XCBShmSEG shmseg;
+  CARD32    shmid;
+  BYTE     *shmaddr;
+};
+
+/**
+ * Create a new Image.
+ * @param conn The connection to the X server.
+ * @param depth The depth of the image.
+ * @param format The format of the image. You can pass XYBitmap,
+ * XYPixmap, or ZPixmap.
+ * @param offset The number of pixels to ignore at the beginning of
+ * the scanline.
+ * @param data The image data.
+ * @param width The width of the image, in pixels.
+ * @param height The height of the image, in pixels.
+ * @param xpad The quantum of a scanline (8, 16, or 32).
+ * @param bytes_per_line The number of bytes in the client image
+ * between the start of one scanline and the start of the next. 
+ * @return The new image.
+ *
+ * This function allocates the memory needed for an XCBImage structure
+ * for the specified connection but does not allocate space for the image
+ * itself. It initializes the structure byte-order, bit-order, and
+ * bitmap-unit values from the connection and returns a pointer to the
+ * XCBImage structure.
+ *
+ * The @p offset parameter permits the rapid displaying of the image
+ * without requiring each scanline to be shifted into position.
+ *
+ * The image must be destroyed with @ref XCBImageDestroy.
+ * @ingroup XCB_Image
+ */
+XCBImage *XCBImageCreate (XCBConnection *conn,
+			  CARD8          depth,
+			  CARD8          format,
+			  unsigned int   offset,
+			  BYTE          *data,
+			  CARD16         width,
+			  CARD16         height,
+			  CARD8          xpad,
+			  CARD32         bytes_per_line);
+
+/**
+ * Initialize an Image.
+ * @param image The image to be destroyed.
+ * @return 1 if the operation has succeeded.
+ *
+ * This function  initializes the image structure.
+ * @ingroup XCB_Image
+ */
+int XCBImageInit (XCBImage *image);
+
+/**
+ * Destroy an Image.
+ * @param image The image to be destroyed.
+ * @return 1 if the operation has succeeded.
+ *
+ * This function deallocates both the memory associated with the @p image
+ * parameter and its data.
+ * @ingroup XCB_Image
+ */
+int XCBImageDestroy (XCBImage *image);
+
+/**
+ * Return a pointer to a XCBImage.
+ * @param conn The connection to the X server.
+ * @param draw The draw you get the image from.
+ * @param x The x coordinate, which are relative to the origin of the
+ * drawable and define the upper-left corner of the rectangle.
+ * @param y The y coordinate, which are relative to the origin of the
+ * drawable and define the upper-left corner of the rectangle.
+ * @param width The width of the subimage, in pixels.
+ * @param height The height of the subimage, in pixels.
+ * @param plane_mask The plane mask.
+ * @param format The format of the image. You can pass XYBitmap,
+ * XYPixmap, or ZPixmap.
+ * @return The subimage of @p draw defined by @p x, @p y, @p w, @p h.
+ *
+ * This function returns a subimage of @p draw defined by @p x, @p y,
+ * @p w, @p h. The depth of the image is the one of the drawable @p
+ * draw, except when getting a subset of the plane in @c XYPixmap
+ * format.
+ *
+ * If a problem occurs, the functons returns @c NULL.
+ * @ingroup XCB_Image
+ */
+XCBImage *XCBImageGet (XCBConnection *conn,
+		       XCBDRAWABLE    draw,
+		       INT16          x,
+		       INT16          y,
+		       CARD16         width,
+		       CARD16         height,
+		       CARD32         plane_mask,
+		       CARD8          format);
+
+/* Not implemented. Should be ? */
+XCBImage xcb_image_subimage_get (XCBConnection *conn,
+				 XCBDRAWABLE    draw,
+				 int            x,
+				 int            y,
+				 unsigned int   width,
+				 unsigned int   height,
+				 unsigned long  plane_mask,
+				 CARD8          format,
+				 XCBImage      *dest_im,
+				 int            dest_x,
+				 int            dest_y);
+
+/**
+ * Put the data of an XCBImage onto a drawable.
+ * @param conn The connection to the X server.
+ * @param draw The draw you get the image from.
+ * @param gc The graphic context.
+ * @param image The image you want to combine with the rectangle.
+ * @param x_offset The offset in x from the left edge of the image
+ * defined by the XCBImage structure.
+ * @param y_offset The offset in y from the left edge of the image
+ * defined by the XCBImage structure.
+ * @param x The x coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of the
+ * rectangle.
+ * @param y The y coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of
+ * the rectangle.
+ * @param width The width of the subimage, in pixels.
+ * @param height The height of the subimage, in pixels.
+ * @return 1 is no problems occurs.
+ *
+ * This function combines an image with a rectangle of the specified
+ * drawable. The section of the image defined by the @p x, @p y,
+ * @p width, and @p height arguments is drawn on the specified part of
+ * the drawable. The foreground pixel in @p gc defines the source for
+ * the one bits in the image, and the background pixel defines the
+ * source for the zero bits. For XYPixmap and ZPixmap formats, the
+ * depth of the image must match the depth of the drawable.
+ *
+ * If a problem occurs, the functons returns @c NULL.
+ * @ingroup XCB_Image
+ */
+int XCBImagePut (XCBConnection *conn,
+		 XCBDRAWABLE    draw,
+		 XCBGCONTEXT    gc,
+		 XCBImage      *image,
+		 INT16          x_offset,
+		 INT16          y_offset,
+		 INT16          x,
+		 INT16          y,
+		 CARD16         width,
+		 CARD16         height);
+
+/**
+ * Put a pixel in a image
+ * @param image The image.
+ * @param x The x coordinate of the pixel.
+ * @param y The y coordinate of the pixel.
+ * @param pixel The new pixel value.
+ * @return 1 if the operation has succeeded.
+ *
+ * This function overwrites the pixel in the named image with the
+ * specified @p pixel value. The input pixel value must be in normalized
+ * format (that is, the least-significant byte of the long is the
+ * least-significant byte of the pixel). The image must contain the @p x
+ * and @p y coordinates.
+ * @ingroup XCB_Image
+ */
+int XCBImagePutPixel (XCBImage *image,
+		      int       x,
+		      int       y,
+		      CARD32    pixel);
+
+/**
+ * Get a pixel in a image
+ * @param image The image.
+ * @param x The x coordinate of the pixel.
+ * @param y The y coordinate of the pixel.
+ * @return The pixel value.
+ *
+ * This function returns the specified pixel from the named image. The
+ * pixel value is returned in normalized format (that is, the
+ * least-significant byte of the long is the least-significant byte of
+ * the pixel). The image must contain the @p x and @p y coordinates. 
+ * @ingroup XCB_Image
+ */
+CARD32 XCBImageGetPixel (XCBImage *image,
+			 int       x,
+			 int       y);
+
+/*
+ * Shm stuff
+ */
+
+/**
+ * Create an XCBImage to be used with the MIT Shm Extension
+ * @param conn The connection to the X server.
+ * @param depth The depth of the image.
+ * @param format The format of the image. You can pass XYBitmap,
+ * XYPixmap, or ZPixmap.
+ * @param data The image data.
+ * @param width The width of the image, in pixels.
+ * @param height The height of the image, in pixels.
+ * @return The new image.
+ *
+ * This function allocates the memory needed for an XCBImage structure
+ * for the specified display but does not allocate space for the image
+ * itself.
+ *
+ * The image must be destroyed with @ref XCBImageSHMDestroy.
+ *
+ * @ingroup XCB_Image
+ */
+XCBImage *XCBImageSHMCreate (XCBConnection *conn,
+			     CARD8          depth,
+			     CARD8          format,
+			     BYTE          *data,
+			     CARD16         width,
+			     CARD16         height);
+
+/**
+ * Destroy an Image created by XCBImageSHMCreate.
+ * @param image The image to be destroyed.
+ * @return 1 if the operation has succeeded.
+ *
+ * This function deallocates both the memory associated with the @p image
+ * parameter and its data.
+ * @ingroup XCB_Image
+ */
+int XCBImageSHMDestroy (XCBImage *image);
+
+/**
+ * Put the data of an XCBImage onto a drawable using the MIT Shm
+ * Extension.
+ * @param conn The connection to the X server.
+ * @param draw The draw you get the image from.
+ * @param gc The graphic context.
+ * @param image The image you want to combine with the rectangle.
+ * @param shminfo A @ref XCBShmSegmentInfo structure.
+ * @param x The offset in x from the left edge of the image
+ * defined by the XCBImage structure.
+ * @param y The offset in y from the left edge of the image
+ * defined by the XCBImage structure.
+ * @param dest_x The x coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of the
+ * rectangle.
+ * @param dest_y The y coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of
+ * the rectangle.
+ * @param width The width of the subimage, in pixels.
+ * @param height The height of the subimage, in pixels.
+ * @param send_event Indicates whether or not a completion event
+ * should occur when the image write is complete.
+ * @return 1 is no problems occurs.
+ *
+ * This function combines an image in memory with a shape of the
+ * specified drawable. The section of the image defined by the @p x, @p y,
+ * @p width, and @p height arguments is drawn on the specified part of
+ * the drawable. If XYBitmap format is used, the depth must be
+ * one, or a``BadMatch'' error results. The foreground pixel in the
+ * Graphic Context @p gc defines the source for the one bits in the
+ * image, and the background pixel defines the source for the zero
+ * bits. For XYPixmap and ZPixmap, the depth must match the depth of
+ * the drawable, or a ``BadMatch'' error results.
+ *
+ * If a problem occurs, the functons returns @c 0. Otherwise, it
+ * returns @c 1.
+ * @ingroup XCB_Image
+ */
+int XCBImageSHMPut (XCBConnection    *conn,
+		    XCBDRAWABLE       draw,
+		    XCBGCONTEXT       gc,
+		    XCBImage         *image,
+		    XCBShmSegmentInfo shminfo,
+		    INT16             x,
+		    INT16             y,
+		    INT16             dest_x,
+		    INT16             dest_y,
+		    CARD16            width,
+		    CARD16            height,
+		    CARD8             send_event);
+
+/**
+ * Read image data into a shared memory XCBImage.
+ * @param conn The connection to the X server.
+ * @param draw The draw you get the image from.
+ * @param image The image you want to combine with the rectangle.
+ * @param shminfo A @ref XCBShmSegmentInfo structure.
+ * @param x The x coordinate, which are relative to the origin of the
+ * drawable and define the upper-left corner of the rectangle.
+ * @param y The y coordinate, which are relative to the origin of the
+ * drawable and define the upper-left corner of the rectangle.
+ * @param plane_mask The plane mask.
+ * @return The subimage of @p draw defined by @p x, @p y, @p w, @p h.
+ *
+ * This function reads image data into a shared memory XCBImage where
+ * @p conn is the connection to the X server, @p draw is the source
+ * drawable, @p image is the destination XCBImage, @p x and @p y are offsets
+ * within the drawable, and @p plane_mask defines which planes are to be
+ * read.
+ *
+ * If a problem occurs, the functons returns @c 0. It returns 1
+ * otherwise.
+ * @ingroup XCB_Image
+ */
+int XCBImageSHMGet (XCBConnection    *conn,
+		    XCBDRAWABLE       draw,
+		    XCBImage         *image,
+		    XCBShmSegmentInfo shminfo,
+		    INT16             x,
+		    INT16             y,
+		    CARD32            plane_mask);
+
+/**
+ * @}
+ */
+
+#endif /* __XCB_IMAGE_H__ */
diff --git a/xcb_util_intro.in b/xcb_util_intro.in
new file mode 100644
index 0000000..482d658
--- /dev/null
+++ b/xcb_util_intro.in
@@ -0,0 +1,21 @@
+/** 
+@file
+@brief XCB Utility functions
+ 
+These routines are used to facilitate the use of XCB in programs
+*/
+
+/**
+
+@mainpage XCB Utility Documentation
+@version @PACKAGE_VERSION@
+@author Jamey Sharp <jamey@minilop.net>
+@author Vincent Torri <torri@iecn.u-nancy.fr>
+@date 2005
+
+
+@section intro What is available ?
+
+@todo Add more functions in XCBAux
+
+*/