Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 1474 insertions, 0 deletions

diff --git a/xorg-server/hw/xgl/xgl.h b/xorg-server/hw/xgl/xgl.h
new file mode 100644
index 000000000..03dc90c70
--- /dev/null
+++ b/xorg-server/hw/xgl/xgl.h
@@ -0,0 +1,1474 @@
+/*
+ * 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 name 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 <davidr@novell.com>
+ */
+
+#ifndef _XGL_H_
+#define _XGL_H_
+
+#include <xgl-config.h>
+
+#include <X11/X.h>
+#define NEED_EVENTS
+#include <X11/Xproto.h>
+#include <X11/Xos.h>
+#include <glitz.h>
+
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "servermd.h"
+#include "mi.h"
+#include "dix.h"
+#include "damage.h"
+#include "gc.h"
+#include "micmap.h"
+/* I'd like gc.h to provide this */
+typedef struct _GCFuncs *GCFuncsPtr;
+
+#ifdef RENDER
+#include "mipict.h"
+#else
+#ifdef XV
+#undef XV /* Xv implementation require RENDER */
+#endif
+#endif
+
+#ifdef XV
+#define XGL_XV_FORMAT_YUY2 0
+#define XGL_XV_FORMAT_YV12 1
+#define XGL_XV_FORMAT_RGB  2
+#define XGL_XV_FORMAT_NUM  3
+#endif
+
+/* For the modules.  We should decide what the actual version numbering should
+ * be.
+ */
+#define VERSION "0.0.1"
+
+extern WindowPtr *WindowTable;
+
+#define XGL_DEFAULT_PBO_MASK 0
+
+typedef struct _xglSizeConstraint {
+    int minWidth;
+    int minHeight;
+    int aboveWidth;
+    int aboveHeight;
+} xglSizeConstraintRec, *xglSizeConstraintPtr;
+
+typedef struct _xglAccelInfo {
+    Bool		 enabled;
+    Bool		 pbuffer;
+    xglSizeConstraintRec size;
+} xglAccelInfoRec, *xglAccelInfoPtr;
+
+typedef struct _xglScreenAccelInfo {
+    xglAccelInfoRec pixmap;
+    xglAccelInfoRec window;
+    xglAccelInfoRec glx;
+    xglAccelInfoRec xv;
+} xglScreenAccelInfoRec, *xglScreenAccelInfoPtr;
+
+typedef struct _xglScreenInfo {
+    glitz_drawable_t	  *drawable;
+    unsigned int	  depth;
+    unsigned int	  width;
+    unsigned int	  height;
+    unsigned int	  widthMm;
+    unsigned int	  heightMm;
+    int			  geometryDataType;
+    int			  geometryUsage;
+    Bool		  yInverted;
+    int			  pboMask;
+    Bool		  lines;
+    xglScreenAccelInfoRec accel;
+} xglScreenInfoRec, *xglScreenInfoPtr;
+
+extern xglScreenInfoRec xglScreenInfo;
+
+typedef struct _xglPixelFormat {
+    CARD8		depth, bitsPerRGB;
+    glitz_pixel_masks_t masks;
+} xglPixelFormatRec, *xglPixelFormatPtr;
+
+typedef struct _xglVisual {
+    struct _xglVisual *next;
+    VisualID	      vid;
+    xglPixelFormatPtr pPixel;
+    Bool	      pbuffer;
+    struct {
+	glitz_drawable_format_t *drawable;
+	glitz_format_t	        *surface;
+    } format;
+} xglVisualRec, *xglVisualPtr;
+
+extern xglVisualPtr xglVisuals;
+
+#define xglAreaAvailable 0
+#define xglAreaDivided   1
+#define xglAreaOccupied  2
+
+typedef struct _xglRootArea *xglRootAreaPtr;
+
+typedef struct _xglArea {
+    int		    state;
+    int		    level;
+    int		    x, y;
+    int		    width, height;
+    struct _xglArea *pArea[4];
+    xglRootAreaPtr  pRoot;
+    pointer	    closure;
+    DevUnion	    devPrivate;
+} xglAreaRec, *xglAreaPtr;
+
+typedef struct _xglAreaFuncs {
+    Bool (*Create)	(xglAreaPtr pArea);
+
+    Bool (*MoveIn)      (xglAreaPtr pArea,
+			 pointer    closure);
+
+    void (*MoveOut)     (xglAreaPtr pArea,
+			 pointer    closure);
+
+    int (*CompareScore) (xglAreaPtr pArea,
+			 pointer    closure1,
+			 pointer    closure2);
+
+} xglAreaFuncsRec, *xglAreaFuncsPtr;
+
+typedef struct _xglRootArea {
+    int		    maxLevel;
+    int		    width, height;
+    xglAreaPtr	    pArea;
+    xglAreaFuncsPtr funcs;
+    int		    devPrivateSize;
+    pointer	    closure;
+} xglRootAreaRec;
+
+typedef struct xglGeometry {
+    glitz_buffer_t          *buffer;
+    pointer	            *data;
+    Bool		    broken;
+    glitz_fixed16_16_t	    xOff, yOff;
+    int			    dataType;
+    int			    usage;
+    int			    size, endOffset;
+    glitz_geometry_type_t   type;
+    glitz_geometry_format_t f;
+    int			    first, width, count;
+    glitz_multi_array_t     *array;
+} xglGeometryRec, *xglGeometryPtr;
+
+#ifdef RENDER
+typedef struct _xglFBox {
+    glitz_float_t x1, y1, x2, y2;
+} xglFBoxRec;
+
+typedef union _xglBox {
+    BoxRec     sBox;
+    xglFBoxRec fBox;
+} xglBoxRec, *xglBoxPtr;
+
+typedef struct _xglRange {
+    int		 first;
+    unsigned int count;
+} xglRangeRec, *xglRangePtr;
+
+typedef struct _xglGlyphTexture {
+    PicturePtr		    pMask;
+    glitz_pixel_format_t    pixel;
+    glitz_geometry_format_t format;
+    int			    geometryDataType;
+} xglGlyphTextureRec, *xglGlyphTexturePtr;
+
+typedef struct _xglGlyphArea {
+    unsigned long serial;
+    union {
+	xglBoxRec   box;
+	xglRangeRec range;
+    } u;
+} xglGlyphAreaRec, *xglGlyphAreaPtr;
+
+typedef struct _xglGlyphCache {
+    ScreenPtr		    pScreen;
+    int			    depth;
+    xglRootAreaRec	    rootArea;
+    union {
+	xglGlyphTextureRec texture;
+	xglGeometryRec	   geometry;
+    } u;
+} xglGlyphCacheRec, *xglGlyphCachePtr;
+
+typedef struct _xglGlyph {
+    xglAreaPtr pArea;
+} xglGlyphRec, *xglGlyphPtr;
+
+extern DevPrivateKey xglGlyphPrivateKey;
+
+#define XGL_GET_GLYPH_PRIV(pScreen, pGlyph) ((xglGlyphPtr)		     \
+    dixLookupPrivate(GetGlyphPrivatesForScreen (pGlyph, pScreen),	     \
+    					        xglGlyphPrivateKey))
+
+#define XGL_GLYPH_PRIV(pScreen, pGlyph)				  \
+    xglGlyphPtr pGlyphPriv = XGL_GET_GLYPH_PRIV (pScreen, pGlyph)
+
+#endif
+
+typedef struct _xglScreen {
+    xglVisualPtr		  pVisual;
+
+#ifdef GLXEXT
+    xglVisualPtr		  pGlxVisual;
+#endif
+
+#ifdef XV
+    xglVisualRec		  pXvVisual[XGL_XV_FORMAT_NUM];
+#endif
+
+    xglVisualPtr		  rootVisual;
+    glitz_drawable_t		  *drawable;
+    glitz_surface_t		  *surface;
+    PixmapPtr			  pScreenPixmap;
+    unsigned long		  features;
+    int				  geometryUsage;
+    int				  geometryDataType;
+    Bool			  yInverted;
+    int				  pboMask;
+    Bool			  lines;
+    xglGeometryRec		  scratchGeometry;
+    xglScreenAccelInfoRec	  accel;
+
+#ifdef RENDER
+    xglGlyphCacheRec		  glyphCache[33];
+    PicturePtr			  pSolidAlpha;
+    struct _trapInfo {
+	PicturePtr		  pMask;
+	glitz_geometry_format_t	  format;
+    } trapInfo;
+#endif
+
+    GetImageProcPtr		  GetImage;
+    GetSpansProcPtr		  GetSpans;
+    CreateWindowProcPtr		  CreateWindow;
+    DestroyWindowProcPtr	  DestroyWindow;
+    ChangeWindowAttributesProcPtr ChangeWindowAttributes;
+    CopyWindowProcPtr		  CopyWindow;
+    CreateGCProcPtr		  CreateGC;
+    CloseScreenProcPtr		  CloseScreen;
+    SetWindowPixmapProcPtr	  SetWindowPixmap;
+    BitmapToRegionProcPtr	  BitmapToRegion;
+
+#ifdef RENDER
+    CompositeProcPtr		  Composite;
+    GlyphsProcPtr		  Glyphs;
+    TrapezoidsProcPtr		  Trapezoids;
+    AddTrapsProcPtr		  AddTraps;
+    AddTrianglesProcPtr		  AddTriangles;
+    ChangePictureProcPtr	  ChangePicture;
+    ChangePictureTransformProcPtr ChangePictureTransform;
+    ChangePictureFilterProcPtr	  ChangePictureFilter;
+
+    RealizeGlyphProcPtr		  RealizeGlyph;
+    UnrealizeGlyphProcPtr	  UnrealizeGlyph;
+#endif
+} xglScreenRec, *xglScreenPtr;
+
+extern DevPrivateKey xglScreenPrivateKey;
+
+#define XGL_GET_SCREEN_PRIV(pScreen) ((xglScreenPtr) \
+    dixLookupPrivate(&(pScreen)->devPrivates, xglScreenPrivateKey))
+
+#define XGL_SET_SCREEN_PRIV(pScreen, v) \
+    dixSetPrivate(&(pScreen)->devPrivates, xglScreenPrivateKey, v)
+
+#define XGL_SCREEN_PRIV(pScreen)			     \
+    xglScreenPtr pScreenPriv = XGL_GET_SCREEN_PRIV (pScreen)
+
+#define XGL_SCREEN_WRAP(field, wrapper)	 \
+    pScreenPriv->field = pScreen->field; \
+    pScreen->field     = wrapper
+
+#define XGL_SCREEN_UNWRAP(field)	\
+    pScreen->field = pScreenPriv->field
+
+#ifdef RENDER
+#define XGL_PICTURE_SCREEN_WRAP(field, wrapper)	   \
+    pScreenPriv->field    = pPictureScreen->field; \
+    pPictureScreen->field = wrapper
+
+#define XGL_PICTURE_SCREEN_UNWRAP(field)       \
+    pPictureScreen->field = pScreenPriv->field
+#endif
+
+#define xglGCSoftwareDrawableFlag (1L << 0)
+#define xglGCBadFunctionFlag	  (1L << 1)
+#define xglGCPlaneMaskFlag	  (1L << 2)
+
+typedef struct _xglGC {
+    glitz_surface_t   *fg;
+    glitz_surface_t   *bg;
+    glitz_format_id_t id;
+    glitz_operator_t  op;
+    unsigned long     flags;
+    GCFuncsPtr	      funcs;
+    GCOpsPtr	      ops;
+} xglGCRec, *xglGCPtr;
+
+extern DevPrivateKey xglGCPrivateKey;
+
+#define XGL_GET_GC_PRIV(pGC) ((xglGCPtr) \
+    dixLookupPrivate(&(pGC)->devPrivates, xglGCPrivateKey))
+
+#define XGL_GC_PRIV(pGC)		     \
+    xglGCPtr pGCPriv = XGL_GET_GC_PRIV (pGC)
+
+#define XGL_GC_WRAP(field, wrapper) \
+    pGCPriv->field = pGC->field;    \
+    pGC->field     = wrapper
+
+#define XGL_GC_UNWRAP(field)    \
+    pGC->field = pGCPriv->field
+
+
+#define xglPCFillMask		(1L << 0)
+#define xglPCFilterMask		(1L << 1)
+#define xglPCTransformMask	(1L << 2)
+#define xglPCComponentAlphaMask (1L << 3)
+#define xglPCDitherMask		(1L << 4)
+
+#define xglPFFilterMask		(1L << 8)
+
+#define xglPixmapTargetNo  0
+#define xglPixmapTargetOut 1
+#define xglPixmapTargetIn  2
+
+#ifdef XV
+
+typedef struct _xglXvPort {
+    PixmapPtr  pPixmap;
+    PicturePtr pSrc;
+    PicturePtr pDst;
+} xglXvPortRec, *xglXvPortPtr;
+
+#endif
+
+typedef struct _xglPixmap {
+    xglVisualPtr     pVisual;
+    glitz_surface_t  *surface;
+    glitz_drawable_t *drawable;
+    glitz_buffer_t   *buffer;
+    int		     target;
+    Bool	     acceleratedTile;
+    pointer	     bits;
+    int		     stride;
+    DamagePtr	     pDamage;
+    BoxRec	     damageBox;
+    RegionRec	     bitRegion;
+    Bool	     allBits;
+    unsigned long    pictureMask;
+    xglGeometryPtr   pGeometry;
+
+#ifdef XV
+    xglXvPortPtr     pPortPriv;
+#endif
+
+} xglPixmapRec, *xglPixmapPtr;
+
+extern DevPrivateKey xglPixmapPrivateKey;
+
+#define XGL_GET_PIXMAP_PRIV(pPixmap) ((xglPixmapPtr) \
+    dixLookupPrivate(&(pPixmap)->devPrivates, xglPixmapPrivateKey))
+
+#define XGL_PIXMAP_PRIV(pPixmap)			     \
+    xglPixmapPtr pPixmapPriv = XGL_GET_PIXMAP_PRIV (pPixmap)
+
+#define XGL_PICTURE_CHANGES(pictureMask)  (pictureMask & 0x0000ffff)
+#define XGL_PICTURE_FAILURES(pictureMask) (pictureMask & 0xffff0000)
+
+typedef struct _xglWin {
+    PixmapPtr    pPixmap;
+} xglWinRec, *xglWinPtr;
+
+extern DevPrivateKey xglWinPrivateKey;
+
+#define XGL_GET_WINDOW_PRIV(pWin) ((xglWinPtr) \
+    dixLookupPrivate(&(pWin)->devPrivates, xglWinPrivateKey))
+
+#define XGL_WINDOW_PRIV(pWin)			    \
+    xglWinPtr pWinPriv = XGL_GET_WINDOW_PRIV (pWin)
+
+#define XGL_GET_WINDOW_PIXMAP(pWin)		       \
+    (XGL_GET_WINDOW_PRIV((WindowPtr) (pWin))->pPixmap)
+
+
+#define XGL_GET_DRAWABLE_PIXMAP(pDrawable)   \
+    (((pDrawable)->type == DRAWABLE_WINDOW)? \
+     XGL_GET_WINDOW_PIXMAP (pDrawable):	     \
+     (PixmapPtr) (pDrawable))
+
+#define XGL_DRAWABLE_PIXMAP(pDrawable)			    \
+    PixmapPtr pPixmap = XGL_GET_DRAWABLE_PIXMAP (pDrawable)
+
+#define XGL_GET_DRAWABLE_PIXMAP_PRIV(pDrawable)		      \
+    XGL_GET_PIXMAP_PRIV (XGL_GET_DRAWABLE_PIXMAP (pDrawable))
+
+#define XGL_DRAWABLE_PIXMAP_PRIV(pDrawable)			        \
+    xglPixmapPtr pPixmapPriv = XGL_GET_DRAWABLE_PIXMAP_PRIV (pDrawable)
+
+#ifdef COMPOSITE
+#define __XGL_OFF_X_WIN(pPix) (-(pPix)->screen_x)
+#define __XGL_OFF_Y_WIN(pPix) (-(pPix)->screen_y)
+#else
+#define __XGL_OFF_X_WIN(pPix) (0)
+#define __XGL_OFF_Y_WIN(pPix) (0)
+#endif
+
+#define XGL_GET_DRAWABLE(pDrawable, pSurface, xOff, yOff)  \
+    {							   \
+	PixmapPtr _pPix;				   \
+	if ((pDrawable)->type != DRAWABLE_PIXMAP) {	   \
+	    _pPix = XGL_GET_WINDOW_PIXMAP (pDrawable);	   \
+	    (xOff) = __XGL_OFF_X_WIN (_pPix);		   \
+	    (yOff) = __XGL_OFF_Y_WIN (_pPix);		   \
+	} else {					   \
+	    _pPix = (PixmapPtr) (pDrawable);		   \
+	    (yOff) = (xOff) = 0;			   \
+	}						   \
+	(pSurface) = XGL_GET_PIXMAP_PRIV (_pPix)->surface; \
+    }
+
+#define XGL_DEFAULT_DPI 96
+
+#define XGL_SW_FAILURE_STRING "software fall-back failure"
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+#define POWER_OF_TWO(v) ((v & (v - 1)) == 0)
+
+#define MOD(a,b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
+
+#define FIXED_TO_FLOAT(f) (((glitz_float_t) (f)) / 65536)
+#define FLOAT_TO_FIXED(f) ((int) ((f) * 65536))
+
+#define BOX_NOTEMPTY(pBox)	      \
+    (((pBox)->x2 - (pBox)->x1) > 0 && \
+     ((pBox)->y2 - (pBox)->y1) > 0)
+
+
+/* xglinput.c */
+
+int
+xglMouseProc (DeviceIntPtr pDevice,
+	      int	   onoff);
+
+int
+xglKeybdProc (DeviceIntPtr pDevice,
+	      int	   onoff);
+
+void
+xglBell (int	      volume,
+	 DeviceIntPtr pDev,
+	 pointer      ctrl,
+	 int	      something);
+
+void
+xglKbdCtrl (DeviceIntPtr pDevice,
+	    KeybdCtrl	 *ctrl);
+
+void
+xglInitInput (int argc, char **argv);
+
+
+/* xgloutput.c */
+
+void
+xglSetPixmapFormats (ScreenInfo *pScreenInfo);
+
+void
+xglSetRootClip (ScreenPtr pScreen,
+		Bool	  enable);
+
+
+/* xglcmap.c */
+
+void
+xglSetVisualTypes (int depth,
+		   int visuals,
+		   int redSize,
+		   int greenSize,
+		   int blueSize);
+
+Bool
+xglHasVisualTypes (xglVisualPtr pVisual,
+		   int		depth);
+
+glitz_format_t *
+xglFindBestSurfaceFormat (ScreenPtr         pScreen,
+			  xglPixelFormatPtr pPixel);
+
+void
+xglInitVisuals (ScreenPtr pScreen);
+
+xglVisualPtr
+xglFindVisualWithDepth (ScreenPtr pScreen,
+			int       depth);
+
+xglVisualPtr
+xglFindVisualWithId (ScreenPtr pScreen,
+		     int       vid);
+
+void
+xglClearVisualTypes (void);
+
+
+/* xglparse.c */
+
+char *
+xglParseFindNext (char *cur,
+		  char *delim,
+		  char *save,
+		  char *last);
+
+void
+xglParseScreen (char *arg);
+
+void
+xglUseMsg (void);
+
+int
+xglProcessArgument (int	 argc,
+		    char **argv,
+		    int	 i);
+
+
+/* xglscreen.c */
+
+Bool
+xglScreenInit (ScreenPtr pScreen);
+
+Bool
+xglFinishScreenInit (ScreenPtr pScreen);
+
+Bool
+xglCloseScreen (int	  index,
+		ScreenPtr pScreen);
+
+void
+xglCreateSolidAlphaPicture (ScreenPtr pScreen);
+
+
+/* xglarea.c */
+
+Bool
+xglRootAreaInit (xglRootAreaPtr	    pRoot,
+		 int		    maxLevel,
+		 int		    width,
+		 int		    height,
+		 int		    devPrivateSize,
+		 xglAreaFuncsPtr    funcs,
+		 pointer	    closure);
+
+void
+xglRootAreaFini (xglRootAreaPtr pRoot);
+
+void
+xglLeaveArea (xglAreaPtr pArea);
+
+void
+xglWithdrawArea (xglAreaPtr pArea);
+
+Bool
+xglFindArea (xglAreaPtr pArea,
+	     int	width,
+	     int	height,
+	     Bool	kickOut,
+	     pointer	closure);
+
+
+/* xglgeometry.c */
+
+#define GEOMETRY_DATA_TYPE_SHORT 0
+#define GEOMETRY_DATA_TYPE_FLOAT 1
+
+typedef struct _xglDataTypeInfo {
+    glitz_data_type_t type;
+    int		      size;
+} xglDataTypeInfoRec, *xglDataTypeInfoPtr;
+
+extern xglDataTypeInfoRec xglGeometryDataTypes[2];
+
+#define DEFAULT_GEOMETRY_DATA_TYPE GEOMETRY_DATA_TYPE_FLOAT
+
+#define GEOMETRY_USAGE_STREAM  0
+#define GEOMETRY_USAGE_STATIC  1
+#define GEOMETRY_USAGE_DYNAMIC 2
+#define GEOMETRY_USAGE_SYSMEM  3
+
+#define DEFAULT_GEOMETRY_USAGE GEOMETRY_USAGE_SYSMEM
+
+#define GEOMETRY_INIT(pScreen, pGeometry, _type, _usage, _size)		  \
+    {									  \
+	(pGeometry)->type      = _type;					  \
+	(pGeometry)->usage     = _usage;				  \
+	(pGeometry)->dataType  = DEFAULT_GEOMETRY_DATA_TYPE;		  \
+	(pGeometry)->usage     = _usage;				  \
+	(pGeometry)->size      = 0;					  \
+	(pGeometry)->endOffset = 0;					  \
+	(pGeometry)->data      = (pointer) 0;				  \
+	(pGeometry)->buffer    = NULL;					  \
+	(pGeometry)->broken    = FALSE;					  \
+	(pGeometry)->xOff      = 0;					  \
+	(pGeometry)->yOff      = 0;					  \
+	(pGeometry)->array     = NULL;					  \
+	(pGeometry)->first     = 0;					  \
+	(pGeometry)->count     = 0;					  \
+	if (_type == GLITZ_GEOMETRY_TYPE_VERTEX)			  \
+	{								  \
+	    (pGeometry)->width = 2;					  \
+	    (pGeometry)->f.vertex.type =				  \
+		xglGeometryDataTypes[(pGeometry)->dataType].type;	  \
+	    (pGeometry)->f.vertex.bytes_per_vertex = (pGeometry)->width * \
+		xglGeometryDataTypes[(pGeometry)->dataType].size;	  \
+	    (pGeometry)->f.vertex.primitive = GLITZ_PRIMITIVE_QUADS;	  \
+	    (pGeometry)->f.vertex.attributes = 0;			  \
+	    (pGeometry)->f.vertex.src.type = GLITZ_DATA_TYPE_FLOAT;	  \
+	    (pGeometry)->f.vertex.src.size = GLITZ_COORDINATE_SIZE_X;	  \
+	    (pGeometry)->f.vertex.src.offset = 0;			  \
+	    (pGeometry)->f.vertex.mask.type = GLITZ_DATA_TYPE_FLOAT;	  \
+	    (pGeometry)->f.vertex.mask.size = GLITZ_COORDINATE_SIZE_X;	  \
+	    (pGeometry)->f.vertex.mask.offset = 0;			  \
+	}								  \
+	else								  \
+	{								  \
+	    (pGeometry)->width = 0;					  \
+	    (pGeometry)->f.bitmap.scanline_order =			  \
+		GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN;			  \
+	    (pGeometry)->f.bitmap.bytes_per_line = 0;			  \
+	    (pGeometry)->f.bitmap.pad = GLYPHPADBYTES;			  \
+	}								  \
+	if (_size)							  \
+	    xglGeometryResize (pScreen, pGeometry, _size);		  \
+    }
+
+#define GEOMETRY_UNINIT(pGeometry)			    \
+    {							    \
+	if ((pGeometry)->array)				    \
+	    glitz_multi_array_destroy ((pGeometry)->array); \
+	if ((pGeometry)->buffer)			    \
+	    glitz_buffer_destroy ((pGeometry)->buffer);     \
+	if ((pGeometry)->data)				    \
+	    xfree ((pGeometry)->data);			    \
+    }
+
+#define GEOMETRY_SET_BUFFER(pGeometry, _buffer)		\
+    {							\
+	glitz_buffer_reference (_buffer);		\
+	if ((pGeometry)->buffer)			\
+	    glitz_buffer_destroy ((pGeometry)->buffer); \
+	(pGeometry)->buffer = _buffer;			\
+    }
+
+#define GEOMETRY_SET_MULTI_ARRAY(pGeometry, _array)	    \
+    {							    \
+	glitz_multi_array_reference (_array);		    \
+	if ((pGeometry)->array)				    \
+	    glitz_multi_array_destroy ((pGeometry)->array); \
+	(pGeometry)->array = _array;			    \
+    }
+
+#define GEOMETRY_RESIZE(pScreen, pGeometry, size) \
+    xglGeometryResize (pScreen, pGeometry, size)
+
+#define GEOMETRY_SET_TRANSLATE(pGeometry, _x, _y) \
+    {						  \
+	(pGeometry)->xOff = (_x) << 16;		  \
+	(pGeometry)->yOff = (_y) << 16;		  \
+    }
+
+#define GEOMETRY_TRANSLATE(pGeometry, tx, ty) \
+    {				              \
+	(pGeometry)->xOff += (tx) << 16;      \
+	(pGeometry)->yOff += (ty) << 16;      \
+    }
+
+#define GEOMETRY_TRANSLATE_FIXED(pGeometry, ftx, fty) \
+    {						      \
+	(pGeometry)->xOff += (ftx);		      \
+	(pGeometry)->yOff += (fty);		      \
+    }
+
+#define GEOMETRY_SET_VERTEX_PRIMITIVE(pGeometry, _primitive) \
+    (pGeometry)->f.vertex.primitive = _primitive
+
+#define GEOMETRY_SET_VERTEX_DATA_TYPE(pGeometry, _type)		       \
+    {								       \
+	(pGeometry)->dataType = _type;				       \
+	(pGeometry)->f.vertex.type = xglGeometryDataTypes[_type].type; \
+	(pGeometry)->f.vertex.bytes_per_vertex = (pGeometry)->width *  \
+	    xglGeometryDataTypes[_type].size;			       \
+    }
+
+#define GEOMETRY_ADD_BOX(pScreen, pGeometry, pBox, nBox) \
+    xglGeometryAddBox (pScreen, pGeometry, pBox, nBox,	 \
+		       (pGeometry)->endOffset)
+
+#define GEOMETRY_ADD_REGION_AT(pScreen, pGeometry, pRegion, offset) \
+     xglGeometryAddBox (pScreen, pGeometry,			    \
+			REGION_RECTS (pRegion),			    \
+			REGION_NUM_RECTS (pRegion),		    \
+			offset)
+
+#define GEOMETRY_ADD_REGION(pScreen, pGeometry, pRegion) \
+    xglGeometryAddBox (pScreen, pGeometry,		 \
+		       REGION_RECTS (pRegion),		 \
+		       REGION_NUM_RECTS (pRegion),	 \
+		       (pGeometry)->endOffset)
+
+#define GEOMETRY_ADD_SPAN(pScreen, pGeometry, ppt, pwidth, n) \
+    xglGeometryAddSpan (pScreen, pGeometry, ppt, pwidth, n,   \
+			(pGeometry)->endOffset)
+
+#define GEOMETRY_ADD_LINE(pScreen, pGeometry, loop, mode, npt, ppt) \
+    xglGeometryAddLine (pScreen, pGeometry, loop, mode, npt, ppt,   \
+			(pGeometry)->endOffset)
+
+#define GEOMETRY_ADD_SEGMENT(pScreen, pGeometry, nsegInit, pSegInit) \
+    xglGeometryAddSegment (pScreen, pGeometry, nsegInit, pSegInit,   \
+			   (pGeometry)->endOffset)
+
+#define GEOMETRY_FOR_GLYPH(pScreen, pGeometry, nGlyph, ppciInit, pglyphBase) \
+    xglGeometryForGlyph (pScreen, pGeometry, nGlyph, ppciInit, pglyphBase);
+
+#define GEOMETRY_ADD_TRAPEZOID(pScreen, pGeometry, pTrap, nTrap) \
+    xglGeometryAddTrapezoid (pScreen, pGeometry, pTrap, nTrap,	 \
+			     (pGeometry)->endOffset)
+
+#define GEOMETRY_ADD_TRAP(pScreen, pGeometry, pTrap, nTrap) \
+    xglGeometryAddTrap (pScreen, pGeometry, pTrap, nTrap,   \
+			(pGeometry)->endOffset)
+
+#define GEOMETRY_GET_FORMAT(pGeometry, format) \
+    xglGeometryGetFormat (pGeometry, format)
+
+#define GEOMETRY_ENABLE(pGeometry, surface) \
+    xglSetGeometry (pGeometry, surface)
+
+#define GEOMETRY_DISABLE(surface)				       \
+    glitz_set_geometry (surface, GLITZ_GEOMETRY_TYPE_NONE, NULL, NULL)
+
+void
+xglGeometryResize (ScreenPtr	  pScreen,
+		   xglGeometryPtr pGeometry,
+		   int		  size);
+
+void
+xglGeometryAddBox (ScreenPtr	  pScreen,
+		   xglGeometryPtr pGeometry,
+		   BoxPtr	  pBox,
+		   int		  nBox,
+		   int		  offset);
+
+void
+xglGeometryAddSpan (ScreenPtr	   pScreen,
+		    xglGeometryPtr pGeometry,
+		    DDXPointPtr	   ppt,
+		    int		   *pwidth,
+		    int		   n,
+		    int		   offset);
+
+void
+xglGeometryAddLine (ScreenPtr	   pScreen,
+		    xglGeometryPtr pGeometry,
+		    int		   loop,
+		    int		   mode,
+		    int		   npt,
+		    DDXPointPtr    ppt,
+		    int		   offset);
+
+void
+xglGeometryAddSegment (ScreenPtr      pScreen,
+		       xglGeometryPtr pGeometry,
+		       int	      nsegInit,
+		       xSegment       *pSegInit,
+		       int	      offset);
+
+void
+xglGeometryForGlyph (ScreenPtr	    pScreen,
+		     xglGeometryPtr pGeometry,
+		     unsigned int   nGlyph,
+		     CharInfoPtr    *ppciInit,
+		     pointer	    pglyphBase);
+
+void
+xglGeometryAddTrapezoid (ScreenPtr	pScreen,
+			 xglGeometryPtr pGeometry,
+			 xTrapezoid	*pTrap,
+			 int		nTrap,
+			 int		offset);
+
+void
+xglGeometryAddTrap (ScreenPtr	   pScreen,
+		    xglGeometryPtr pGeometry,
+		    xTrap	   *pTrap,
+		    int		   nTrap,
+		    int		   offset);
+
+xglGeometryPtr
+xglGetScratchGeometryWithSize (ScreenPtr pScreen,
+			       int	 size);
+
+xglGeometryPtr
+xglGetScratchVertexGeometryWithType (ScreenPtr pScreen,
+				     int       type,
+				     int       count);
+
+xglGeometryPtr
+xglGetScratchVertexGeometry (ScreenPtr pScreen,
+			     int       count);
+
+Bool
+xglSetGeometry (xglGeometryPtr	pGeometry,
+		glitz_surface_t *surface);
+
+
+/* xglpixmap.c */
+
+#define XGL_PIXMAP_USAGE_HINT_STREAM_DRAW  1
+#define XGL_PIXMAP_USAGE_HINT_STREAM_READ  2
+#define XGL_PIXMAP_USAGE_HINT_STREAM_COPY  3
+#define XGL_PIXMAP_USAGE_HINT_STATIC_DRAW  4
+#define XGL_PIXMAP_USAGE_HINT_STATIC_READ  5
+#define XGL_PIXMAP_USAGE_HINT_STATIC_COPY  6
+#define XGL_PIXMAP_USAGE_HINT_DYNAMIC_DRAW 7
+#define XGL_PIXMAP_USAGE_HINT_DYNAMIC_READ 8
+#define XGL_PIXMAP_USAGE_HINT_DYNAMIC_COPY 9
+
+#define XGL_PIXMAP_USAGE_HINT_DEFAULT XGL_PIXMAP_USAGE_HINT_STREAM_DRAW
+
+PixmapPtr
+xglCreatePixmap (ScreenPtr  pScreen,
+		 int	    width,
+		 int	    height,
+		 int	    depth,
+		 unsigned   usage_hint);
+
+void
+xglFiniPixmap (PixmapPtr pPixmap);
+
+Bool
+xglDestroyPixmap (PixmapPtr pPixmap);
+
+Bool
+xglModifyPixmapHeader (PixmapPtr pPixmap,
+		       int	 width,
+		       int	 height,
+		       int	 depth,
+		       int	 bitsPerPixel,
+		       int	 devKind,
+		       pointer	 pPixData);
+
+void
+xglSetPixmapVisual (PixmapPtr    pPixmap,
+		    xglVisualPtr pVisual);
+
+RegionPtr
+xglPixmapToRegion (PixmapPtr pPixmap);
+
+xglGeometryPtr
+xglPixmapToGeometry (PixmapPtr pPixmap,
+		     int       xOff,
+		     int       yOff);
+
+Bool
+xglCreatePixmapSurface (PixmapPtr pPixmap);
+
+Bool
+xglAllocatePixmapBits (PixmapPtr pPixmap, int hint);
+
+Bool
+xglMapPixmapBits (PixmapPtr pPixmap);
+
+Bool
+xglUnmapPixmapBits (PixmapPtr pPixmap);
+
+Bool
+xglCheckPixmapSize (PixmapPtr		 pPixmap,
+		    xglSizeConstraintPtr pSize);
+
+void
+xglEnablePixmapAccel (PixmapPtr	      pPixmap,
+		      xglAccelInfoPtr pAccel);
+
+
+/* xglsync.c */
+
+Bool
+xglSyncBits (DrawablePtr pDrawable,
+	     BoxPtr	 pExtents);
+
+void
+xglSyncDamageBoxBits (DrawablePtr pDrawable);
+
+Bool
+xglSyncSurface (DrawablePtr pDrawable);
+
+Bool
+xglPrepareTarget (DrawablePtr pDrawable);
+
+void
+xglAddSurfaceDamage (DrawablePtr pDrawable,
+		     RegionPtr   pRegion);
+
+void
+xglAddCurrentSurfaceDamage (DrawablePtr pDrawable);
+
+void
+xglAddBitDamage (DrawablePtr pDrawable,
+		 RegionPtr   pRegion);
+
+void
+xglAddCurrentBitDamage (DrawablePtr pDrawable);
+
+
+/* xglsolid.c */
+
+Bool
+xglSolid (DrawablePtr	   pDrawable,
+	  glitz_operator_t op,
+	  glitz_surface_t  *solid,
+	  xglGeometryPtr   pGeometry,
+	  int		   x,
+	  int		   y,
+	  int		   width,
+	  int		   height,
+	  BoxPtr	   pBox,
+	  int		   nBox);
+
+Bool
+xglSolidGlyph (DrawablePtr  pDrawable,
+	       GCPtr	    pGC,
+	       int	    x,
+	       int	    y,
+	       unsigned int nGlyph,
+	       CharInfoPtr  *ppci,
+	       pointer      pglyphBase);
+
+
+/* xgltile.c */
+
+xglGeometryPtr
+xglTiledBoxGeometry (PixmapPtr pTile,
+		     int       tileX,
+		     int       tileY,
+		     BoxPtr    pBox,
+		     int       nBox);
+
+Bool
+xglTile (DrawablePtr	  pDrawable,
+	 glitz_operator_t op,
+	 PixmapPtr	  pTile,
+	 int		  tileX,
+	 int		  tileY,
+	 xglGeometryPtr	  pGeometry,
+	 int		  x,
+	 int		  y,
+	 int		  width,
+	 int		  height,
+	 BoxPtr		  pBox,
+	 int		  nBox);
+
+
+/* xglcopy.c */
+
+Bool
+xglCopy (DrawablePtr pSrc,
+	 DrawablePtr pDst,
+	 int	     dx,
+	 int	     dy,
+	 BoxPtr	     pBox,
+	 int	     nBox);
+
+void
+xglCopyProc (DrawablePtr pSrc,
+	     DrawablePtr pDst,
+	     GCPtr	 pGC,
+	     BoxPtr	 pBox,
+	     int	 nBox,
+	     int	 dx,
+	     int	 dy,
+	     Bool	 reverse,
+	     Bool	 upsidedown,
+	     Pixel	 bitplane,
+	     void	 *closure);
+
+
+/* xglfill.c */
+
+Bool
+xglFill (DrawablePtr	pDrawable,
+	 GCPtr		pGC,
+	 xglGeometryPtr pGeometry,
+	 int		x,
+	 int		y,
+	 int		width,
+	 int		height,
+	 BoxPtr		pBox,
+	 int		nBox);
+
+void
+xglFillSpan (DrawablePtr pDrawable,
+	     GCPtr	 pGC,
+	     int	 n,
+	     DDXPointPtr ppt,
+	     int	 *pwidth);
+
+void
+xglFillRect (DrawablePtr pDrawable,
+	     GCPtr	 pGC,
+	     int	 nrect,
+	     xRectangle  *prect);
+
+Bool
+xglFillLine (DrawablePtr pDrawable,
+	     GCPtr       pGC,
+	     int	 mode,
+	     int	 npt,
+	     DDXPointPtr ppt);
+
+Bool
+xglFillSegment (DrawablePtr pDrawable,
+		GCPtr	    pGC,
+		int	    nsegInit,
+		xSegment    *pSegInit);
+
+Bool
+xglFillGlyph (DrawablePtr  pDrawable,
+	      GCPtr	   pGC,
+	      int	   x,
+	      int	   y,
+	      unsigned int nglyph,
+	      CharInfoPtr  *ppciInit,
+	      pointer      pglyphBase);
+
+
+/* xglwindow.c */
+
+Bool
+xglCreateWindow (WindowPtr pWin);
+
+Bool
+xglDestroyWindow (WindowPtr pWin);
+
+Bool
+xglChangeWindowAttributes (WindowPtr	 pWin,
+			   unsigned long mask);
+
+void
+xglCopyWindow (WindowPtr   pWin,
+	       DDXPointRec ptOldOrg,
+	       RegionPtr   prgnSrc);
+
+PixmapPtr
+xglGetWindowPixmap (WindowPtr pWin);
+
+void
+xglSetWindowPixmap (WindowPtr pWin,
+		    PixmapPtr pPixmap);
+
+
+/* xglget.c */
+
+void
+xglGetImage (DrawablePtr   pDrawable,
+	     int	   x,
+	     int	   y,
+	     int	   w,
+	     int	   h,
+	     unsigned int  format,
+	     unsigned long planeMask,
+	     char	   *d);
+
+void
+xglGetSpans (DrawablePtr pDrawable,
+	     int	 wMax,
+	     DDXPointPtr ppt,
+	     int	 *pwidth,
+	     int	 nspans,
+	     char	 *pchardstStart);
+
+
+/* xglgc.c */
+
+Bool
+xglCreateGC (GCPtr pGC);
+
+void
+xglDestroyGC (GCPtr pGC);
+
+void
+xglValidateGC (GCPtr	     pGC,
+	       unsigned long changes,
+	       DrawablePtr   pDrawable);
+
+void
+xglFillSpans  (DrawablePtr pDrawable,
+	       GCPtr	   pGC,
+	       int	   nspans,
+	       DDXPointPtr ppt,
+	       int	   *pwidth,
+	       int	   fSorted);
+
+void
+xglSetSpans (DrawablePtr pDrawable,
+	     GCPtr	 pGC,
+	     char	 *psrc,
+	     DDXPointPtr ppt,
+	     int	 *pwidth,
+	     int	 nspans,
+	     int	 fSorted);
+
+void
+xglPutImage (DrawablePtr pDrawable,
+	     GCPtr	 pGC,
+	     int	 depth,
+	     int	 x,
+	     int	 y,
+	     int	 w,
+	     int	 h,
+	     int	 leftPad,
+	     int	 format,
+	     char	 *bits);
+
+RegionPtr
+xglCopyArea (DrawablePtr pSrc,
+	     DrawablePtr pDst,
+	     GCPtr	 pGC,
+	     int	 srcX,
+	     int	 srcY,
+	     int	 w,
+	     int	 h,
+	     int	 dstX,
+	     int	 dstY);
+
+RegionPtr
+xglCopyPlane (DrawablePtr   pSrc,
+	      DrawablePtr   pDst,
+	      GCPtr	    pGC,
+	      int	    srcX,
+	      int	    srcY,
+	      int	    w,
+	      int	    h,
+	      int	    dstX,
+	      int	    dstY,
+	      unsigned long bitPlane);
+
+void
+xglPolyPoint (DrawablePtr pDrawable,
+	      GCPtr       pGC,
+	      int	  mode,
+	      int	  npt,
+	      DDXPointPtr pptInit);
+
+void
+xglPolylines (DrawablePtr pDrawable,
+	      GCPtr       pGC,
+	      int	  mode,
+	      int	  npt,
+	      DDXPointPtr ppt);
+
+void
+xglPolySegment (DrawablePtr pDrawable,
+		GCPtr	    pGC,
+		int	    nsegInit,
+		xSegment    *pSegInit);
+
+void
+xglPolyArc (DrawablePtr pDrawable,
+	    GCPtr	pGC,
+	    int		narcs,
+	    xArc	*pArcs);
+
+void
+xglPolyFillRect (DrawablePtr pDrawable,
+		 GCPtr	     pGC,
+		 int	     nrect,
+		 xRectangle  *prect);
+
+void
+xglPolyFillArc (DrawablePtr pDrawable,
+		GCPtr	    pGC,
+		int	    narcs,
+		xArc	    *pArcs);
+
+void
+xglImageGlyphBlt (DrawablePtr  pDrawable,
+		  GCPtr	       pGC,
+		  int	       x,
+		  int	       y,
+		  unsigned int nglyph,
+		  CharInfoPtr  *ppci,
+		  pointer      pglyphBase);
+
+void
+xglPolyGlyphBlt (DrawablePtr  pDrawable,
+		 GCPtr	      pGC,
+		 int	      x,
+		 int	      y,
+		 unsigned int nglyph,
+		 CharInfoPtr  *ppci,
+		 pointer      pglyphBase);
+void
+xglPushPixels (GCPtr	   pGC,
+	       PixmapPtr   pBitmap,
+	       DrawablePtr pDrawable,
+	       int	   w,
+	       int	   h,
+	       int	   x,
+	       int	   y);
+
+
+#ifdef MITSHM
+
+/* xglshm.c */
+
+void
+xglShmPutImage (DrawablePtr  pDrawable,
+		GCPtr	     pGC,
+		int	     depth,
+		unsigned int format,
+		int	     w,
+		int	     h,
+		int	     sx,
+		int	     sy,
+		int	     sw,
+		int	     sh,
+		int	     dx,
+		int	     dy,
+		char	     *data);
+
+#endif
+
+
+#ifdef RENDER
+
+/* xglpict.c */
+
+void
+xglComposite (CARD8	 op,
+	      PicturePtr pSrc,
+	      PicturePtr pMask,
+	      PicturePtr pDst,
+	      INT16	 xSrc,
+	      INT16	 ySrc,
+	      INT16	 xMask,
+	      INT16	 yMask,
+	      INT16	 xDst,
+	      INT16	 yDst,
+	      CARD16	 width,
+	      CARD16	 height);
+
+void
+xglAddTriangles (PicturePtr pDst,
+		 INT16	    xOff,
+		 INT16	    yOff,
+		 int	    ntri,
+		 xTriangle  *tris);
+
+void
+xglChangePicture (PicturePtr pPicture,
+		  Mask	     mask);
+
+int
+xglChangePictureTransform (PicturePtr    pPicture,
+			   PictTransform *transform);
+
+int
+xglChangePictureFilter (PicturePtr pPicture,
+			int	   filter,
+			xFixed	   *params,
+			int	   nparams);
+
+PicturePtr
+xglCreateDevicePicture (pointer data);
+
+Bool
+xglSyncPicture (ScreenPtr  pScreen,
+		PicturePtr pPicture,
+		INT16	   x,
+		INT16	   y,
+		CARD16	   width,
+		CARD16	   height,
+		INT16	   *xOff,
+		INT16	   *yOff);
+
+Bool
+xglPictureInit (ScreenPtr pScreen);
+
+void
+xglPictureClipExtents (PicturePtr pPicture,
+		       BoxPtr     extents);
+
+
+/* xglcompose.c */
+
+Bool
+xglCompositeGeneral (CARD8	     op,
+		     PicturePtr	     pSrc,
+		     PicturePtr	     pMask,
+		     PicturePtr	     pDst,
+		     xglGeometryPtr  pGeometry,
+		     INT16	     xSrc,
+		     INT16	     ySrc,
+		     INT16	     xMask,
+		     INT16	     yMask,
+		     INT16	     xDst,
+		     INT16	     yDst,
+		     CARD16	     width,
+		     CARD16	     height);
+
+
+/* xglglyph.c */
+
+Bool
+xglRealizeGlyph (ScreenPtr pScreen,
+		 GlyphPtr  pGlyph);
+
+void
+xglUnrealizeGlyph (ScreenPtr pScreen,
+		   GlyphPtr  pGlyph);
+
+Bool
+xglInitGlyphCache (xglGlyphCachePtr pCache,
+		   ScreenPtr	    pScreen,
+		   PictFormatPtr    format);
+
+void
+xglFiniGlyphCache (xglGlyphCachePtr pCache);
+
+void
+xglGlyphs (CARD8	 op,
+	   PicturePtr	 pSrc,
+	   PicturePtr	 pDst,
+	   PictFormatPtr maskFormat,
+	   INT16	 xSrc,
+	   INT16	 ySrc,
+	   int		 nlist,
+	   GlyphListPtr	 list,
+	   GlyphPtr	 *glyphs);
+
+
+/* xgltrap.c */
+
+void
+xglTrapezoids (CARD8	     op,
+	       PicturePtr    pSrc,
+	       PicturePtr    pDst,
+	       PictFormatPtr maskFormat,
+	       INT16	     xSrc,
+	       INT16	     ySrc,
+	       int	     nTrap,
+	       xTrapezoid    *traps);
+
+void
+xglAddTraps (PicturePtr pDst,
+	     INT16	xOff,
+	     INT16	yOff,
+	     int	nTrap,
+	     xTrap	*traps);
+
+#endif
+
+#ifdef XGL_MODULAR
+
+/* xglloader.c */
+
+typedef struct _xglSymbol {
+    void       **ptr;
+    const char *name;
+} xglSymbolRec, *xglSymbolPtr;
+
+void *
+xglLoadModule (const char *name,
+	       int	  flag);
+
+void
+xglUnloadModule (void *handle);
+
+Bool
+xglLookupSymbols (void         *handle,
+		  xglSymbolPtr sym,
+		  int	       nSym);
+
+#endif
+
+
+/* xglxv.c */
+
+#ifdef XV
+
+Bool
+xglXvScreenInit (ScreenPtr pScreen);
+
+#endif
+
+
+/* xglhash.c */
+
+typedef struct _xglHashTable *xglHashTablePtr;
+
+Bool
+xglLoadHashFuncs (void *handle);
+
+xglHashTablePtr
+xglNewHashTable (void);
+
+void
+xglDeleteHashTable (xglHashTablePtr pTable);
+
+void *
+xglHashLookup (const xglHashTablePtr pTable,
+	       unsigned int	     key);
+
+void
+xglHashInsert (xglHashTablePtr pTable,
+	       unsigned int    key,
+	       void	       *data);
+
+void
+xglHashRemove (xglHashTablePtr pTable,
+	       unsigned int    key);
+
+unsigned int
+xglHashFirstEntry (xglHashTablePtr pTable);
+
+unsigned int
+xglHashNextEntry (const xglHashTablePtr pTable,
+		  unsigned int		key);
+
+unsigned int
+xglHashFindFreeKeyBlock (xglHashTablePtr pTable,
+			 unsigned int	 numKeys);
+
+#endif /* _XGL_H_ */