diff --git a/objects/Makefile b/objects/Makefile
new file mode 100644
index 0000000..ad4d119
--- /dev/null
+++ b/objects/Makefile
@@ -0,0 +1,19 @@
+CFLAGS=$(COPTS) $(DEBUGOPTS) -I$(INCLUDE_DIR)
+
+OBJS=bitmap.o brush.o font.o gdiobj.o palette.o pen.o dib.o region.o \
+	text.o dcvalues.o clipping.o bitblt.o linedda.o
+
+default: objects.o
+
+objects.o: $(OBJS)
+	$(LD) -r -o objects.o $(OBJS)
+
+clean:
+	rm -f *.o *~ *.s dll_* *.a
+
+depend:
+	$(CC) $(CFLAGS) -M *.c > .depend
+
+ifeq (.depend,$(wildcard .depend))
+include .depend
+endif
diff --git a/objects/bitblt.c b/objects/bitblt.c
new file mode 100644
index 0000000..53e9ba1
--- /dev/null
+++ b/objects/bitblt.c
@@ -0,0 +1,111 @@
+/*
+ * GDI bit-blit operations
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <X11/Xlib.h>
+
+#include "gdi.h"
+
+extern const int DC_XROPfunction[];
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+
+/***********************************************************************
+ *           PatBlt    (GDI.29)
+ */
+BOOL PatBlt( HDC hdc, short left, short top,
+	     short width, short height, DWORD rop)
+{
+    int x1, x2, y1, y2;
+    
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return FALSE;
+#ifdef DEBUG_GDI
+    printf( "PatBlt: %d %d,%d %dx%d %06x\n",
+	    hdc, left, top, width, height, rop );
+#endif
+
+    rop >>= 16;
+    if (!DC_SetupGCForBrush( dc )) rop &= 0x0f;
+    else rop = (rop & 0x03) | ((rop >> 4) & 0x0c);
+    XSetFunction( XT_display, dc->u.x.gc, DC_XROPfunction[rop] );
+
+    x1 = XLPTODP( dc, left );
+    x2 = XLPTODP( dc, left + width );
+    y1 = YLPTODP( dc, top );
+    y2 = YLPTODP( dc, top + height );
+    XFillRectangle( XT_display, dc->u.x.drawable, dc->u.x.gc,
+		   MIN(x1,x2), MIN(y1,y2), abs(x2-x1), abs(y2-y1) );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           BitBlt    (GDI.34)
+ */
+BOOL BitBlt( HDC hdcDest, short xDest, short yDest, short width, short height,
+	     HDC hdcSrc, short xSrc, short ySrc, DWORD rop )
+{
+    int xs1, xs2, ys1, ys2;
+    int xd1, xd2, yd1, yd2;
+    DC *dcDest, *dcSrc;
+
+#ifdef DEBUG_GDI    
+    printf( "BitBlt: %d %d,%d %dx%d %d %d,%d %08x\n",
+	   hdcDest, xDest, yDest, width, height, hdcSrc, xSrc, ySrc, rop );
+#endif
+
+    if ((rop & 0xcc0000) == ((rop & 0x330000) << 2))
+	return PatBlt( hdcDest, xDest, yDest, width, height, rop );
+
+    rop >>= 16;
+    if ((rop & 0x0f) != (rop >> 4))
+    {
+	printf( "BitBlt: Unimplemented ROP %02x\n", rop );
+	return FALSE;
+    }
+    
+    dcDest = (DC *) GDI_GetObjPtr( hdcDest, DC_MAGIC );
+    if (!dcDest) return FALSE;
+    dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+    if (!dcSrc) return FALSE;
+
+    xs1 = XLPTODP( dcSrc, xSrc );
+    xs2 = XLPTODP( dcSrc, xSrc + width );
+    ys1 = YLPTODP( dcSrc, ySrc );
+    ys2 = YLPTODP( dcSrc, ySrc + height );
+    xd1 = XLPTODP( dcDest, xDest );
+    xd2 = XLPTODP( dcDest, xDest + width );
+    yd1 = YLPTODP( dcDest, yDest );
+    yd2 = YLPTODP( dcDest, yDest + height );
+
+    if ((abs(xs2-xs1) != abs(xd2-xd1)) || (abs(ys2-ys1) != abs(yd2-yd1)))
+	return FALSE;  /* Should call StretchBlt here */
+    
+    DC_SetupGCForText( dcDest );
+    XSetFunction( XT_display, dcDest->u.x.gc, DC_XROPfunction[rop & 0x0f] );
+    if (dcSrc->w.bitsPerPixel == dcDest->w.bitsPerPixel)
+    {
+	XCopyArea( XT_display, dcSrc->u.x.drawable,
+		   dcDest->u.x.drawable, dcDest->u.x.gc,
+		   MIN(xs1,xs2), MIN(ys1,ys2), abs(xs2-xs1), abs(ys2-ys1),
+		   MIN(xd1,xd2), MIN(yd1,yd2) );
+    }
+    else
+    {
+	if (dcSrc->w.bitsPerPixel != 1) return FALSE;
+	XCopyPlane( XT_display, dcSrc->u.x.drawable,
+		    dcDest->u.x.drawable, dcDest->u.x.gc,
+		    MIN(xs1,xs2), MIN(ys1,ys2), abs(xs2-xs1), abs(ys2-ys1),
+		    MIN(xd1,xd2), MIN(yd1,yd2), 1 );
+    }
+    return TRUE;
+}
diff --git a/objects/bitmap.c b/objects/bitmap.c
new file mode 100644
index 0000000..9de4c1c
--- /dev/null
+++ b/objects/bitmap.c
@@ -0,0 +1,423 @@
+/*
+ * GDI bitmap objects
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include "gdi.h"
+
+/* A GDI bitmap object contains a handle to a packed BITMAP,
+ * which is stored on the global heap.
+ * A packed BITMAP is a BITMAP structure followed by the bitmap bits.
+ */
+
+  /* Handle of the bitmap selected by default in a memory DC */
+HBITMAP BITMAP_hbitmapMemDC;
+
+  /* List of supported depths */
+static int depthCount;
+static int * depthList;
+
+  /* List of GC used for bitmap to pixmap operations (one for each depth) */
+static GC * bitmapGC;
+
+
+/***********************************************************************
+ *           BITMAP_Init
+ */
+BOOL BITMAP_Init()
+{
+    int i;
+    Pixmap tmpPixmap;
+    
+    depthList = XListDepths( XT_display, DefaultScreen(XT_display), 
+			     &depthCount );
+    if (!depthList || !depthCount) return FALSE;
+    if (!(bitmapGC = (GC *) malloc( depthCount * sizeof(GC) ))) return FALSE;
+    
+      /* Create the necessary GCs */
+    
+    for (i = 0; i < depthCount; i++)
+    {
+	tmpPixmap = XCreatePixmap( XT_display, DefaultRootWindow(XT_display),
+				  1, 1, depthList[i] );
+	if (tmpPixmap)
+	{
+	    bitmapGC[i] = XCreateGC( XT_display, tmpPixmap, 0, NULL );
+	    XFreePixmap( XT_display, tmpPixmap );
+	}
+	else bitmapGC[i] = 0;
+    }
+
+    BITMAP_hbitmapMemDC = CreateBitmap( 1, 1, 1, 1, NULL );
+    return (BITMAP_hbitmapMemDC != 0);
+}
+
+
+/***********************************************************************
+ *           BITMAP_FindGCForDepth
+ *
+ * Return a GC appropriate for operations with the given depth.
+ */
+GC BITMAP_FindGCForDepth( int depth )
+{
+    int i;
+    for (i = 0; i < depthCount; i++)
+	if (depthList[i] == depth) return bitmapGC[i];
+    return 0;
+}
+
+
+/***********************************************************************
+ *           BITMAP_BmpToImage
+ *
+ * Create an XImage pointing to the bitmap data.
+ */
+XImage * BITMAP_BmpToImage( BITMAP * bmp, void * bmpData )
+{
+    XImage * image;
+
+    image = XCreateImage( XT_display, DefaultVisualOfScreen(XT_screen),
+			  bmp->bmBitsPixel, ZPixmap, 0, bmpData,
+			  bmp->bmWidth, bmp->bmHeight, 16, bmp->bmWidthBytes );
+    if (!image) return 0;
+    image->byte_order = MSBFirst;
+    image->bitmap_bit_order = MSBFirst;
+    image->bitmap_unit = 16;
+    _XInitImageFuncPtrs(image);
+    return image;
+}
+
+
+/***********************************************************************
+ *           BITMAP_CopyToPixmap
+ *
+ * Copy the content of the bitmap to the pixmap. Both must have the same depth.
+ */
+BOOL BITMAP_CopyToPixmap( BITMAP * bmp, Pixmap pixmap,
+			  int x, int y, int width, int height )
+{
+    GC gc;
+    XImage * image;
+    
+    gc = BITMAP_FindGCForDepth( bmp->bmBitsPixel );
+    if (!gc) return FALSE;
+    
+    image = BITMAP_BmpToImage( bmp, ((char *)bmp) + sizeof(BITMAP) );
+    if (!image) return FALSE;
+
+#ifdef DEBUG_GDI
+    printf( "BITMAP_CopyToPixmap: %dx%d %d colors -> %d,%d %dx%d\n",
+	    bmp->bmWidth, bmp->bmHeight, 1 << bmp->bmBitsPixel, x, y, width, height );
+#endif
+    XPutImage(XT_display, pixmap, gc, image, 0, 0, x, y, width, height); 
+    image->data = NULL;
+    XDestroyImage( image );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           BITMAP_CopyFromPixmap
+ *
+ * Copy the content of the pixmap to the bitmap. Both must have
+ * the same dimensions and depth.
+ */
+BOOL BITMAP_CopyFromPixmap( BITMAP * bmp, Pixmap pixmap )
+{
+    XImage *image = BITMAP_BmpToImage( bmp, ((char *)bmp) + sizeof(BITMAP) );
+    if (!image) return FALSE;
+
+#ifdef DEBUG_GDI
+    printf( "BITMAP_CopyFromPixmap: %dx%d %d colors\n",
+	    bmp->bmWidth, bmp->bmHeight, 1 << bmp->bmBitsPixel );
+#endif    
+    XGetSubImage( XT_display, pixmap, 0, 0, bmp->bmWidth, bmp->bmHeight,
+		  AllPlanes, ZPixmap, image, 0, 0 );
+    image->data = NULL;
+    XDestroyImage( image );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           CreateBitmap    (GDI.48)
+ */
+HBITMAP CreateBitmap( short width, short height, 
+		      BYTE planes, BYTE bpp, LPSTR bits )
+{
+    BITMAP bitmap = { 0, width, height, 0, planes, bpp, bits };
+#ifdef DEBUG_GDI
+    printf( "CreateBitmap: %dx%d, %d colors\n", 
+	     width, height, 1 << (planes*bpp) );
+#endif
+    if (!width || !height) return 0;
+    if ((planes != 1) && (bpp != 1)) return 0;
+    bitmap.bmWidthBytes = (width * bpp + 15) / 16 * 2;
+    return CreateBitmapIndirect( &bitmap );
+}
+
+
+/***********************************************************************
+ *           CreateCompatibleBitmap    (GDI.51)
+ */
+HBITMAP CreateCompatibleBitmap( HDC hdc, short width, short height )
+{
+    HBITMAP hbitmap;
+    DC * dc;
+#ifdef DEBUG_GDI
+    printf( "CreateCompatibleBitmap: %d %dx%d\n", hdc, width, height );
+#endif
+    dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return 0;
+    hbitmap = CreateBitmap( width, height, dc->w.planes, dc->w.bitsPerPixel, NULL);
+    return hbitmap;
+}
+
+
+/***********************************************************************
+ *           CreateBitmapIndirect    (GDI.49)
+ */
+HBITMAP CreateBitmapIndirect( BITMAP * bmp )
+{
+    BITMAPOBJ * bmpObjPtr;
+    char * bmpPtr;
+    HBITMAP hbitmap;
+    int size = bmp->bmPlanes * bmp->bmHeight * bmp->bmWidthBytes;
+    
+      /* Create the BITMAPOBJ */
+
+    hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
+    if (!hbitmap) return 0;
+    bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_ADDR( hbitmap );
+    
+      /* Create the bitmap in global heap */
+
+    bmpObjPtr->hBitmap = GlobalAlloc( GMEM_MOVEABLE, sizeof(BITMAP) + size );
+    if (!bmpObjPtr->hBitmap)
+    {
+	GDI_FreeObject( hbitmap );
+	return 0;
+    }
+    bmpPtr = (char *) GlobalLock( bmpObjPtr->hBitmap );
+    memcpy( bmpPtr, bmp, sizeof(BITMAP) );
+    ((BITMAP *)bmpPtr)->bmBits = NULL;
+    if (bmp->bmBits) memcpy( bmpPtr + sizeof(BITMAP), bmp->bmBits, size );
+    GlobalUnlock( bmpObjPtr->hBitmap );
+
+    bmpObjPtr->bSelected = FALSE;
+    bmpObjPtr->hdc       = 0;
+    bmpObjPtr->size.cx   = 0;
+    bmpObjPtr->size.cy   = 0;
+    return hbitmap;
+}
+
+
+/***********************************************************************
+ *           BITMAP_GetSetBitmapBits
+ */
+LONG BITMAP_GetSetBitmapBits( HBITMAP hbitmap, LONG count,
+			      LPSTR buffer, int set )
+{
+    BITMAPOBJ * bmpObjPtr;
+    BITMAP * bmp;
+    DC * dc = NULL;
+    int maxSize;
+    
+    if (!count) return 0;
+    bmpObjPtr = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
+    if (!bmpObjPtr) return 0;
+    if (!(bmp = (BITMAP *) GlobalLock( bmpObjPtr->hBitmap ))) return 0;
+    
+    if (bmpObjPtr->bSelected) 
+	dc = (DC *) GDI_GetObjPtr( bmpObjPtr->hdc, DC_MAGIC );
+
+    maxSize = bmp->bmPlanes * bmp->bmHeight * bmp->bmWidthBytes;
+    if (count > maxSize) count = maxSize;
+    	
+    if (set)
+    {
+	memcpy( bmp+1, buffer, count );
+	if (dc) BITMAP_CopyToPixmap( bmp, dc->u.x.drawable,
+				     0, 0, bmp->bmWidth, bmp->bmHeight );
+    }
+    else
+    {
+	if (dc) BITMAP_CopyFromPixmap( bmp, dc->u.x.drawable );
+	memcpy( buffer, bmp+1, count );
+    }
+    GlobalUnlock( bmpObjPtr->hBitmap );
+    return hbitmap;
+}
+
+
+/***********************************************************************
+ *           GetBitmapBits    (GDI.74)
+ */
+LONG GetBitmapBits( HBITMAP hbitmap, LONG count, LPSTR buffer )
+{
+    return BITMAP_GetSetBitmapBits( hbitmap, count, buffer, 0 );
+}
+
+
+/***********************************************************************
+ *           SetBitmapBits    (GDI.106)
+ */
+LONG SetBitmapBits( HBITMAP hbitmap, LONG count, LPSTR buffer )
+{
+    return BITMAP_GetSetBitmapBits( hbitmap, count, buffer, 1 );
+}
+
+
+/***********************************************************************
+ *           BMP_DeleteObject
+ */
+BOOL BMP_DeleteObject( HBITMAP hbitmap, BITMAPOBJ * bitmap )
+{
+      /* Free bitmap on global heap */
+    GlobalFree( bitmap->hBitmap );
+    return GDI_FreeObject( hbitmap );
+}
+
+	
+/***********************************************************************
+ *           BMP_GetObject
+ */
+int BMP_GetObject( BITMAPOBJ * bitmap, int count, LPSTR buffer )
+{
+    char * bmpPtr = (char *) GlobalLock( bitmap->hBitmap );    
+    if (count > sizeof(BITMAP)) count = sizeof(BITMAP);
+    memcpy( buffer, bmpPtr, count );
+    GlobalUnlock( bitmap->hBitmap );
+    return count;
+}
+
+    
+/***********************************************************************
+ *           BITMAP_UnselectBitmap
+ *
+ * Unselect the bitmap from the DC. Used by SelectObject and DeleteDC.
+ */
+BOOL BITMAP_UnselectBitmap( DC * dc )
+{
+    BITMAPOBJ * bmp;
+    BITMAP * bmpPtr;
+
+    if (!dc->w.hBitmap) return TRUE;
+    bmp = (BITMAPOBJ *) GDI_GetObjPtr( dc->w.hBitmap, BITMAP_MAGIC );
+    if (!bmp) return FALSE;
+    
+    if (!(bmpPtr = (BITMAP *) GlobalLock( bmp->hBitmap ))) return FALSE;
+    
+    BITMAP_CopyFromPixmap( bmpPtr, dc->u.x.drawable );
+    XFreePixmap( XT_display, dc->u.x.drawable );
+    bmp->bSelected = FALSE;
+    bmp->hdc       = 0;
+    GlobalUnlock( bmp->hBitmap );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           BITMAP_SelectObject
+ */
+HBITMAP BITMAP_SelectObject( HDC hdc, DC * dc, HBITMAP hbitmap,
+			     BITMAPOBJ * bitmap )
+{
+    BITMAP * bmp;
+    HBITMAP prevHandle = dc->w.hBitmap;
+    
+    if (!(dc->w.flags & DC_MEMORY)) return 0;
+    if (bitmap->bSelected && hbitmap != BITMAP_hbitmapMemDC) return 0;
+    if (!(bmp = (BITMAP *) GlobalLock( bitmap->hBitmap ))) return 0;
+
+      /* Make sure the bitmap has the right format */
+
+    if ((bmp->bmPlanes != 1) || !BITMAP_FindGCForDepth( bmp->bmBitsPixel ))
+    {
+	GlobalUnlock( bitmap->hBitmap );
+	return 0;
+    }
+    
+      /* Unselect the previous bitmap */
+
+    if (!BITMAP_UnselectBitmap( dc ))
+    {
+	GlobalUnlock( bitmap->hBitmap );
+	return 0;
+    }
+    
+      /* Create the pixmap */
+    
+    dc->u.x.drawable   = XCreatePixmap( XT_display,
+				        DefaultRootWindow( XT_display ), 
+				        bmp->bmWidth, bmp->bmHeight,
+				        bmp->bmBitsPixel );
+    BITMAP_CopyToPixmap( bmp, dc->u.x.drawable,
+			 0, 0, bmp->bmWidth, bmp->bmHeight );
+
+      /* Change GC depth if needed */
+
+    if (dc->w.bitsPerPixel != bmp->bmBitsPixel)
+    {
+	XFreeGC( XT_display, dc->u.x.gc );
+	dc->u.x.gc = XCreateGC( XT_display, dc->u.x.drawable, 0, NULL );
+	dc->w.bitsPerPixel = bmp->bmBitsPixel;
+	DC_SetDeviceInfo( hdc, dc );
+    }
+    
+    GlobalUnlock( bitmap->hBitmap );
+    dc->w.hBitmap     = hbitmap;
+    bitmap->bSelected = TRUE;
+    bitmap->hdc       = hdc;
+    return prevHandle;
+}
+
+
+/***********************************************************************
+ *           GetBitmapDimensionEx    (GDI.468)
+ */
+BOOL GetBitmapDimensionEx( HBITMAP hbitmap, LPSIZE size )
+{
+    BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
+    if (!bmp) return FALSE;
+    *size = bmp->size;
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           GetBitmapDimension    (GDI.162)
+ */
+DWORD GetBitmapDimension( HBITMAP hbitmap )
+{
+    SIZE size;
+    if (!GetBitmapDimensionEx( hbitmap, &size )) return 0;
+    return size.cx | (size.cy << 16);
+}
+
+/***********************************************************************
+ *           SetBitmapDimensionEx    (GDI.478)
+ */
+BOOL SetBitmapDimensionEx( HBITMAP hbitmap, short x, short y, LPSIZE prevSize )
+{
+    BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
+    if (!bmp) return FALSE;
+    if (prevSize) *prevSize = bmp->size;
+    bmp->size.cx = x;
+    bmp->size.cy = y;
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           SetBitmapDimension    (GDI.163)
+ */
+DWORD SetBitmapDimension( HBITMAP hbitmap, short x, short y )
+{
+    SIZE size;
+    if (!SetBitmapDimensionEx( hbitmap, x, y, &size )) return 0;
+    return size.cx | (size.cy << 16);    
+}
diff --git a/objects/brush.c b/objects/brush.c
new file mode 100644
index 0000000..11a430b
--- /dev/null
+++ b/objects/brush.c
@@ -0,0 +1,270 @@
+/*
+ * GDI brush objects
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include "gdi.h"
+
+extern Display * XT_display;
+extern Screen * XT_screen;
+
+#define NB_HATCH_STYLES  6
+
+static char HatchBrushes[NB_HATCH_STYLES][8] =
+{
+    { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 }, /* HS_HORIZONTAL */
+    { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* HS_VERTICAL   */
+    { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HS_FDIAGONAL  */
+    { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HS_BDIAGONAL  */
+    { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 }, /* HS_CROSS      */
+    { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 }  /* HS_DIAGCROSS  */
+};
+
+extern XImage * BITMAP_BmpToImage( BITMAP *, void * );
+
+/***********************************************************************
+ *           CreateBrushIndirect    (GDI.50)
+ */
+HBRUSH CreateBrushIndirect( LOGBRUSH * brush )
+{
+    BRUSHOBJ * brushPtr;
+    HBRUSH hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
+    if (!hbrush) return 0;
+    brushPtr = (BRUSHOBJ *) GDI_HEAP_ADDR( hbrush );
+    memcpy( &brushPtr->logbrush, brush, sizeof(LOGBRUSH) );
+    return hbrush;
+}
+
+
+/***********************************************************************
+ *           CreateHatchBrush    (GDI.58)
+ */
+HBRUSH CreateHatchBrush( short style, COLORREF color )
+{
+    LOGBRUSH logbrush = { BS_HATCHED, color, style };
+#ifdef DEBUG_GDI
+    printf( "CreateHatchBrush: %d %06x\n", style, color );
+#endif
+    if ((style < 0) || (style >= NB_HATCH_STYLES)) return 0;
+    return CreateBrushIndirect( &logbrush );
+}
+
+
+/***********************************************************************
+ *           CreatePatternBrush    (GDI.60)
+ */
+HBRUSH CreatePatternBrush( HBITMAP hbitmap )
+{
+    LOGBRUSH logbrush = { BS_PATTERN, 0, 0 };
+    BITMAPOBJ * bmpObj;
+    BITMAP * bmp;
+    
+#ifdef DEBUG_GDI
+    printf( "CreatePatternBrush: %d\n", hbitmap );
+#endif
+
+      /* Make a copy of the bitmap */
+
+    if (!(bmpObj = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
+	return 0;
+    if (!(bmp = (BITMAP *) GlobalLock( bmpObj->hBitmap ))) return 0;    
+    logbrush.lbHatch = CreateBitmap( bmp->bmWidth, bmp->bmHeight,
+				     bmp->bmPlanes, bmp->bmBitsPixel,
+				     ((char *)bmp) + sizeof(BITMAP) );
+    GlobalUnlock( bmpObj->hBitmap );
+    if (!logbrush.lbHatch) return 0;
+    return CreateBrushIndirect( &logbrush );
+}
+
+
+/***********************************************************************
+ *           CreateDIBPatternBrush    (GDI.445)
+ */
+HBRUSH CreateDIBPatternBrush( HANDLE hbitmap, WORD coloruse )
+{
+    LOGBRUSH logbrush = { BS_DIBPATTERN, coloruse, 0 };
+    BITMAPINFO *info, *newInfo;
+    int size;
+    
+#ifdef DEBUG_GDI
+    printf( "CreateDIBPatternBrush: %d\n", hbitmap );
+#endif
+
+      /* Make a copy of the bitmap */
+
+    if (!(info = (BITMAPINFO *) GlobalLock( hbitmap ))) return 0;
+
+    size = info->bmiHeader.biSizeImage;
+    if (!size)
+	size = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) / 32
+	         * 8 * info->bmiHeader.biHeight;
+    size += DIB_BitmapInfoSize( info, coloruse );
+
+    if (!(logbrush.lbHatch = GlobalAlloc( GMEM_MOVEABLE, size )))
+    {
+	GlobalUnlock( hbitmap );
+	return 0;
+    }
+    newInfo = (BITMAPINFO *) GlobalLock( logbrush.lbHatch );
+    memcpy( newInfo, info, size );
+    GlobalUnlock( logbrush.lbHatch );
+    GlobalUnlock( hbitmap );
+    return CreateBrushIndirect( &logbrush );
+}
+
+
+/***********************************************************************
+ *           CreateSolidBrush    (GDI.66)
+ */
+HBRUSH CreateSolidBrush( COLORREF color )
+{
+    LOGBRUSH logbrush = { BS_SOLID, color, 0 };
+#ifdef DEBUG_GDI
+    printf( "CreateSolidBrush: %06x\n", color );
+#endif
+    return CreateBrushIndirect( &logbrush );
+}
+
+
+/***********************************************************************
+ *           SetBrushOrg    (GDI.148)
+ */
+DWORD SetBrushOrg( HDC hdc, short x, short y )
+{
+    DWORD retval;
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return FALSE;
+    retval = dc->w.brushOrgX | (dc->w.brushOrgY << 16);
+    dc->w.brushOrgX = x;
+    dc->w.brushOrgY = y;
+    return retval;
+}
+
+
+/***********************************************************************
+ *           BRUSH_DeleteObject
+ */
+BOOL BRUSH_DeleteObject( HBRUSH hbrush, BRUSHOBJ * brush )
+{
+    switch(brush->logbrush.lbStyle)
+    {
+      case BS_PATTERN:
+	  DeleteObject( brush->logbrush.lbHatch );
+	  break;
+      case BS_DIBPATTERN:
+	  GlobalFree( brush->logbrush.lbHatch );
+	  break;
+    }
+    return GDI_FreeObject( hbrush );
+}
+
+
+/***********************************************************************
+ *           BRUSH_GetObject
+ */
+int BRUSH_GetObject( BRUSHOBJ * brush, int count, LPSTR buffer )
+{
+    if (count > sizeof(LOGBRUSH)) count = sizeof(LOGBRUSH);
+    memcpy( buffer, &brush->logbrush, count );
+    return count;
+}
+
+
+/***********************************************************************
+ *           BRUSH_SelectPatternBrush
+ */
+BOOL BRUSH_SelectPatternBrush( DC * dc, HBITMAP hbitmap )
+{
+    BITMAPOBJ * bmpObjPtr;
+    BITMAP * bmp;
+    
+    bmpObjPtr = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
+    if (!bmpObjPtr) return FALSE;
+    if (!(bmp = (BITMAP *) GlobalLock( bmpObjPtr->hBitmap ))) return FALSE;
+
+    dc->u.x.brush.pixmap = XCreatePixmap( XT_display,
+					  DefaultRootWindow(XT_display),
+					  8, 8, bmp->bmBitsPixel );
+    BITMAP_CopyToPixmap( bmp, dc->u.x.brush.pixmap, 0, 0, 8, 8 );
+    
+    if (bmp->bmBitsPixel > 1)
+    {
+	dc->u.x.brush.fillStyle = FillTiled;
+	XSetTile( XT_display, dc->u.x.gc, dc->u.x.brush.pixmap );
+	dc->u.x.brush.pixel = 0;  /* Ignored */
+    }
+    else
+    {
+	dc->u.x.brush.fillStyle = FillOpaqueStippled;
+	XSetStipple( XT_display, dc->u.x.gc, dc->u.x.brush.pixmap );
+	dc->u.x.brush.pixel = -1;  /* Special case (see DC_SetupGCForBrush) */
+    }
+    return TRUE;
+}
+
+
+
+/***********************************************************************
+ *           BRUSH_SelectObject
+ */
+HBRUSH BRUSH_SelectObject( HDC hdc, DC * dc, HBRUSH hbrush, BRUSHOBJ * brush )
+{
+    HBITMAP hBitmap;
+    BITMAPINFO * bmpInfo;
+    HBRUSH prevHandle = dc->w.hBrush;
+    
+    dc->w.hBrush = hbrush;
+
+    if (dc->u.x.brush.pixmap)
+    {
+	XFreePixmap( XT_display, dc->u.x.brush.pixmap );
+	dc->u.x.brush.pixmap = 0;
+    }
+    dc->u.x.brush.style = brush->logbrush.lbStyle;
+    
+    switch(brush->logbrush.lbStyle)
+    {
+      case BS_SOLID:
+      case BS_NULL:
+	dc->u.x.brush.pixel = GetNearestPaletteIndex( dc->w.hPalette, 
+						 brush->logbrush.lbColor );
+	dc->u.x.brush.fillStyle = FillSolid;
+	break;
+	
+      case BS_HATCHED:
+	dc->u.x.brush.pixel = GetNearestPaletteIndex( dc->w.hPalette, 
+						 brush->logbrush.lbColor );
+	dc->u.x.brush.pixmap = XCreateBitmapFromData(XT_display, 
+					DefaultRootWindow(XT_display),
+					HatchBrushes[brush->logbrush.lbHatch],
+					8, 8 );
+	XSetStipple( XT_display, dc->u.x.gc, dc->u.x.brush.pixmap );
+	dc->u.x.brush.fillStyle = FillStippled;
+	break;
+	
+      case BS_PATTERN:
+	BRUSH_SelectPatternBrush( dc, brush->logbrush.lbHatch );
+	break;
+
+      case BS_DIBPATTERN:
+	if ((bmpInfo = (BITMAPINFO *) GlobalLock( brush->logbrush.lbHatch )))
+	{
+	    int size = DIB_BitmapInfoSize( bmpInfo, brush->logbrush.lbColor );
+	    hBitmap = CreateDIBitmap( hdc, &bmpInfo->bmiHeader, CBM_INIT,
+				      ((char *)bmpInfo) + size, bmpInfo,
+				      (WORD) brush->logbrush.lbColor );
+	    BRUSH_SelectPatternBrush( dc, hBitmap );
+	    DeleteObject( hBitmap );
+	    GlobalUnlock( brush->logbrush.lbHatch );	    
+	}
+	
+	break;
+    }
+    
+    return prevHandle;
+}
+
+
diff --git a/objects/clipping.c b/objects/clipping.c
new file mode 100644
index 0000000..ec9de9c
--- /dev/null
+++ b/objects/clipping.c
@@ -0,0 +1,354 @@
+/*
+ * DC clipping functions
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include <stdio.h>
+#include "gdi.h"
+
+
+/***********************************************************************
+ *           CLIPPING_UpdateGCRegion
+ *
+ * Update the GC clip region when the ClipRgn of VisRgn have changed.
+ */
+static void CLIPPING_UpdateGCRegion( DC * dc )
+{
+    if (!dc->w.hGCClipRgn) dc->w.hGCClipRgn = CreateRectRgn(0,0,0,0);
+
+    if (!dc->w.hVisRgn)
+    {
+	if (!dc->w.hClipRgn)
+	{
+	    DeleteObject( dc->w.hGCClipRgn );
+	    dc->w.hGCClipRgn = 0;
+	}
+	else
+	    CombineRgn( dc->w.hGCClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
+    }
+    else
+    {
+	if (!dc->w.hClipRgn)
+	    CombineRgn( dc->w.hGCClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
+	else
+	    CombineRgn( dc->w.hGCClipRgn, dc->w.hClipRgn, dc->w.hVisRgn, RGN_AND );
+    }
+    
+    if (dc->w.hGCClipRgn)
+    {
+	RGNOBJ *obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hGCClipRgn, REGION_MAGIC );
+	XSetClipMask( XT_display, dc->u.x.gc, obj->region.pixmap );
+	XSetClipOrigin( XT_display, dc->u.x.gc,
+		        obj->region.box.left, obj->region.box.top );
+    }
+    else
+    {
+	XSetClipMask( XT_display, dc->u.x.gc, None );
+	XSetClipOrigin( XT_display, dc->u.x.gc, 0, 0 );
+    }	
+}
+
+
+/***********************************************************************
+ *           CLIPPING_SelectRgn
+ *
+ * Helper function for SelectClipRgn() and SelectVisRgn().
+ */
+static int CLIPPING_SelectRgn( DC * dc, HRGN * hrgnPrev, HRGN hrgn )
+{
+    int retval;
+    
+    if (hrgn)
+    {
+	if (!*hrgnPrev) *hrgnPrev = CreateRectRgn(0,0,0,0);
+	retval = CombineRgn( *hrgnPrev, hrgn, 0, RGN_COPY );
+    }
+    else
+    {
+	if (*hrgnPrev) DeleteObject( *hrgnPrev );
+	*hrgnPrev = 0;
+	retval = SIMPLEREGION; /* Clip region == client area */
+    }
+    CLIPPING_UpdateGCRegion( dc );
+    return retval;
+}
+
+
+/***********************************************************************
+ *           SelectClipRgn    (GDI.44)
+ */
+int SelectClipRgn( HDC hdc, HRGN hrgn )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;
+    
+#ifdef DEBUG_CLIPPING
+    printf( "SelectClipRgn: %d %d\n", hdc, hrgn );
+#endif
+    return CLIPPING_SelectRgn( dc, &dc->w.hClipRgn, hrgn );
+}
+
+
+/***********************************************************************
+ *           SelectVisRgn    (GDI.105)
+ */
+int SelectVisRgn( HDC hdc, HRGN hrgn )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;
+    
+#ifdef DEBUG_CLIPPING
+    printf( "SelectVisRgn: %d %d\n", hdc, hrgn );
+#endif
+    return CLIPPING_SelectRgn( dc, &dc->w.hVisRgn, hrgn );
+}
+
+
+/***********************************************************************
+ *           OffsetClipRgn    (GDI.32)
+ */
+int OffsetClipRgn( HDC hdc, short x, short y )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "OffsetClipRgn: %d %d,%d\n", hdc, x, y );
+#endif
+
+    if (dc->w.hClipRgn)
+    {
+	int retval = OffsetRgn( dc->w.hClipRgn, x, y );
+	CLIPPING_UpdateGCRegion( dc );
+	return retval;
+    }
+    else return SIMPLEREGION; /* Clip region == client area */
+}
+
+
+/***********************************************************************
+ *           OffsetVisRgn    (GDI.102)
+ */
+int OffsetVisRgn( HDC hdc, short x, short y )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "OffsetVisRgn: %d %d,%d\n", hdc, x, y );
+#endif
+
+    if (dc->w.hVisRgn)
+    {
+	int retval = OffsetRgn( dc->w.hVisRgn, x, y );
+	CLIPPING_UpdateGCRegion( dc );
+	return retval;
+    }
+    else return SIMPLEREGION; /* Clip region == client area */
+}
+
+
+/***********************************************************************
+ *           CLIPPING_IntersectRect
+ *
+ * Helper function for {Intersect,Exclude}{Clip,Vis}Rect
+ */
+int CLIPPING_IntersectRect( DC * dc, HRGN * hrgn, short left, short top,
+			    short right, short bottom, int exclude )
+{
+    HRGN tempRgn, newRgn;
+    RGNOBJ *newObj, *prevObj;
+    int retval;
+
+    if (!*hrgn) return NULLREGION;
+    if (!(newRgn = CreateRectRgn( 0, 0, 0, 0))) return ERROR;
+    if (!(tempRgn = CreateRectRgn( left, top, right, bottom )))
+    {
+	DeleteObject( newRgn );
+	return ERROR;
+    }
+    retval = CombineRgn( newRgn, *hrgn, tempRgn, exclude ? RGN_DIFF : RGN_AND);
+    newObj = (RGNOBJ *) GDI_GetObjPtr( newRgn, REGION_MAGIC );
+    prevObj = (RGNOBJ *) GDI_GetObjPtr( *hrgn, REGION_MAGIC );
+    if (newObj && prevObj) newObj->header.hNext = prevObj->header.hNext;
+    DeleteObject( tempRgn );
+    DeleteObject( *hrgn );
+    *hrgn = newRgn;    
+    CLIPPING_UpdateGCRegion( dc );
+    return retval;
+}
+
+
+/***********************************************************************
+ *           ExcludeClipRect    (GDI.21)
+ */
+int ExcludeClipRect( HDC hdc, short left, short top,
+		     short right, short bottom )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "ExcludeClipRect: %d %dx%d,%dx%d\n",
+	    hdc, left, top, right, bottom );
+#endif
+    return CLIPPING_IntersectRect( dc, &dc->w.hClipRgn, left, top,
+				   right, bottom, 1 );
+}
+
+
+/***********************************************************************
+ *           IntersectClipRect    (GDI.22)
+ */
+int IntersectClipRect( HDC hdc, short left, short top,
+		       short right, short bottom )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "IntersectClipRect: %d %dx%d,%dx%d\n",
+	    hdc, left, top, right, bottom );
+#endif
+    return CLIPPING_IntersectRect( dc, &dc->w.hClipRgn, left, top,
+				   right, bottom, 0 );
+}
+
+
+/***********************************************************************
+ *           ExcludeVisRect    (GDI.73)
+ */
+int ExcludeVisRect( HDC hdc, short left, short top,
+		    short right, short bottom )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "ExcludeVisRect: %d %dx%d,%dx%d\n",
+	    hdc, left, top, right, bottom );
+#endif
+    return CLIPPING_IntersectRect( dc, &dc->w.hVisRgn, left, top,
+				   right, bottom, 1 );
+}
+
+
+/***********************************************************************
+ *           IntersectVisRect    (GDI.98)
+ */
+int IntersectVisRect( HDC hdc, short left, short top,
+		      short right, short bottom )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "IntersectVisRect: %d %dx%d,%dx%d\n",
+	    hdc, left, top, right, bottom );
+#endif
+    return CLIPPING_IntersectRect( dc, &dc->w.hVisRgn, left, top,
+				   right, bottom, 0 );
+}
+
+
+/***********************************************************************
+ *           PtVisible    (GDI.103)
+ */
+BOOL PtVisible( HDC hdc, short x, short y )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "PtVisible: %d %d,%d\n", hdc, x, y );
+#endif
+    if (!dc->w.hClipRgn) return FALSE;
+    return PtInRegion( dc->w.hClipRgn, x, y );
+}
+
+
+/***********************************************************************
+ *           RectVisible    (GDI.104)
+ */
+BOOL RectVisible( HDC hdc, LPRECT rect )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "RectVisible: %d %p\n", hdc, rect );
+#endif
+    if (!dc->w.hClipRgn) return FALSE;
+    return RectInRegion( dc->w.hClipRgn, rect );
+}
+
+
+/***********************************************************************
+ *           GetClipBox    (GDI.77)
+ */
+int GetClipBox( HDC hdc, LPRECT rect )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "GetClipBox: %d %p\n", hdc, rect );
+#endif
+
+    if (dc->w.hGCClipRgn) return GetRgnBox( dc->w.hGCClipRgn, rect );
+    else
+    {
+	Window root;
+	int width, height, x, y, border, depth;
+	XGetGeometry( XT_display, dc->u.x.drawable, &root, &x, &y, 
+		      &width, &height, &border, &depth );
+	rect->top = rect->left = 0;
+	rect->right  = width & 0xffff;
+	rect->bottom = height & 0xffff;
+	return SIMPLEREGION;
+    }
+}
+
+
+/***********************************************************************
+ *           SaveVisRgn    (GDI.129)
+ */
+HRGN SaveVisRgn( HDC hdc )
+{
+    HRGN copy;
+    RGNOBJ *obj, *copyObj;
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return 0;
+#ifdef DEBUG_CLIPPING
+    printf( "SaveVisRgn: %d\n", hdc );
+#endif
+    if (!dc->w.hVisRgn) return 0;
+    if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
+	return 0;
+    if (!(copy = CreateRectRgn( 0, 0, 0, 0 ))) return 0;
+    CombineRgn( copy, dc->w.hVisRgn, 0, RGN_COPY );
+    if (!(copyObj = (RGNOBJ *) GDI_GetObjPtr( copy, REGION_MAGIC )))
+	return 0;
+    copyObj->header.hNext = obj->header.hNext;
+    obj->header.hNext = copy;
+    return copy;
+}
+
+
+/***********************************************************************
+ *           RestoreVisRgn    (GDI.130)
+ */
+int RestoreVisRgn( HDC hdc )
+{
+    HRGN saved;
+    RGNOBJ *obj, *savedObj;
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return ERROR;    
+#ifdef DEBUG_CLIPPING
+    printf( "RestoreVisRgn: %d\n", hdc );
+#endif
+    if (!dc->w.hVisRgn) return ERROR;
+    if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
+	return ERROR;
+    if (!(saved = obj->header.hNext)) return ERROR;
+    if (!(savedObj = (RGNOBJ *) GDI_GetObjPtr( saved, REGION_MAGIC )))
+	return ERROR;
+    DeleteObject( dc->w.hVisRgn );
+    dc->w.hVisRgn = saved;
+    CLIPPING_UpdateGCRegion( dc );
+    return savedObj->region.type;
+}
diff --git a/objects/dcvalues.c b/objects/dcvalues.c
new file mode 100644
index 0000000..b496e2e
--- /dev/null
+++ b/objects/dcvalues.c
@@ -0,0 +1,142 @@
+/*
+ * DC device-independent Get/SetXXX functions
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include "gdi.h"
+
+  /* Default DC values */
+const WIN_DC_INFO DCVAL_defaultValues =
+{
+    0,                      /* flags */
+    NULL,                   /* devCaps */
+    0,                      /* hMetaFile */
+    0,                      /* hClipRgn */
+    0,                      /* hVisRgn */
+    0,                      /* hGCClipRgn */
+    STOCK_BLACK_PEN,        /* hPen */
+    STOCK_WHITE_BRUSH,      /* hBrush */
+    STOCK_SYSTEM_FONT,      /* hFont */
+    0,                      /* hBitmap */
+    0,                      /* hDevice */
+    STOCK_DEFAULT_PALETTE,  /* hPalette */
+    R2_COPYPEN,             /* ROPmode */
+    ALTERNATE,              /* polyFillMode */
+    BLACKONWHITE,           /* stretchBltMode */
+    ABSOLUTE,               /* relAbsMode */
+    OPAQUE,                 /* backgroundMode */
+    RGB( 255, 255, 255 ),   /* backgroundColor */
+    RGB( 0, 0, 0 ),         /* textColor */
+    0,                      /* backgroundPixel */
+    0,                      /* textPixel */
+    0,                      /* brushOrgX */
+    0,                      /* brushOrgY */
+    TA_LEFT | TA_TOP | TA_NOUPDATECP,  /* textAlign */
+    0,                      /* charExtra */
+    0,                      /* breakTotalExtra */
+    0,                      /* breakCount */
+    0,                      /* breakExtra */
+    0,                      /* breakRem */
+    1,                      /* planes */
+    1,                      /* bitsPerPixel */
+    MM_TEXT,                /* MapMode */
+    0,                      /* DCOrgX */
+    0,                      /* DCOrgY */
+    0,                      /* CursPosX */
+    0,                      /* CursPosY */
+    0,                      /* WndOrgX */
+    0,                      /* WndOrgY */
+    1,                      /* WndExtX */
+    1,                      /* WndExtY */
+    0,                      /* VportOrgX */
+    0,                      /* VportOrgY */
+    1,                      /* VportExtX */
+    1                       /* VportExtY */
+};
+
+
+#define DC_GET_VAL( func_type, func_name, dc_field ) \
+func_type func_name( HDC hdc ) \
+{ \
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
+    if (!dc) return 0; \
+    return dc->w.dc_field; \
+}
+
+#define DC_GET_X_Y( func_type, func_name, ret_x, ret_y ) \
+func_type func_name( HDC hdc ) \
+{ \
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
+    if (!dc) return 0; \
+    return dc->w.ret_x | (dc->w.ret_y << 16); \
+}
+
+#define DC_GET_VAL_EX( func_name, ret_x, ret_y ) \
+BOOL func_name( HDC hdc, LPPOINT pt ) \
+{ \
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
+    if (!dc) return FALSE; \
+    pt->x = dc->w.ret_x; \
+    pt->y = dc->w.ret_y; \
+    return TRUE; \
+}
+
+#define DC_SET_VAL( func_type, func_name, dc_field ) \
+func_type func_name( HDC hdc, func_type val ) \
+{ \
+    func_type prevVal; \
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
+    if (!dc) return 0; \
+    prevVal = dc->w.dc_field; \
+    dc->w.dc_field = val; \
+    return prevVal; \
+}
+
+#define DC_SET_MODE( func_name, dc_field, min_val, max_val ) \
+WORD func_name( HDC hdc, WORD mode ) \
+{ \
+    WORD prevMode; \
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
+    if (!dc) return 0; \
+    if ((mode < min_val) || (mode > max_val)) return 0; \
+    prevMode = dc->w.dc_field; \
+    dc->w.dc_field = mode; \
+    return prevMode; \
+}
+
+
+DC_SET_MODE( SetBkMode, backgroundMode, TRANSPARENT, OPAQUE )     /* GDI.2 */
+DC_SET_MODE( SetROP2, ROPmode, R2_BLACK, R2_WHITE )               /* GDI.4 */
+DC_SET_MODE( SetRelAbs, relAbsMode, ABSOLUTE, RELATIVE )          /* GDI.5 */
+DC_SET_MODE( SetPolyFillMode, polyFillMode, ALTERNATE, WINDING )  /* GDI.6 */
+DC_SET_MODE( SetStretchBltMode, stretchBltMode,
+	     BLACKONWHITE, COLORONCOLOR )                         /* GDI.7 */
+DC_GET_VAL( COLORREF, GetBkColor, backgroundColor )               /* GDI.75 */
+DC_GET_VAL( WORD, GetBkMode, backgroundMode )                     /* GDI.76 */
+DC_GET_X_Y( DWORD, GetCurrentPosition, CursPosX, CursPosY )       /* GDI.78 */
+DC_GET_X_Y( DWORD, GetDCOrg, DCOrgX, DCOrgY )                     /* GDI.79 */
+DC_GET_VAL( WORD, GetMapMode, MapMode )                           /* GDI.81 */
+DC_GET_VAL( WORD, GetPolyFillMode, polyFillMode )                 /* GDI.84 */
+DC_GET_VAL( WORD, GetROP2, ROPmode )                              /* GDI.85 */
+DC_GET_VAL( WORD, GetRelAbs, relAbsMode )                         /* GDI.86 */
+DC_GET_VAL( WORD, GetStretchBltMode, stretchBltMode )             /* GDI.88 */
+DC_GET_VAL( COLORREF, GetTextColor, textColor )                   /* GDI.90 */
+DC_GET_X_Y( DWORD, GetViewportExt, VportExtX, VportExtY )         /* GDI.94 */
+DC_GET_X_Y( DWORD, GetViewportOrg, VportOrgX, VportOrgY )         /* GDI.95 */
+DC_GET_X_Y( DWORD, GetWindowExt, WndExtX, WndExtY )               /* GDI.96 */
+DC_GET_X_Y( DWORD, GetWindowOrg, WndOrgX, WndOrgY )               /* GDI.97 */
+DC_GET_VAL( HRGN, InquireVisRgn, hVisRgn )                        /* GDI.131 */
+DC_GET_X_Y( DWORD, GetBrushOrg, brushOrgX, brushOrgY )            /* GDI.149 */
+DC_GET_VAL( HRGN, GetClipRgn, hClipRgn )                          /* GDI.173 */
+DC_GET_VAL( WORD, GetTextAlign, textAlign )                       /* GDI.345 */
+DC_SET_VAL( WORD, SetTextAlign, textAlign )                       /* GDI.346 */
+DC_GET_VAL( HFONT, GetCurLogFont, hFont )                         /* GDI.411 */
+DC_GET_VAL_EX( GetBrushOrgEx, brushOrgX, brushOrgY )              /* GDI.469 */
+DC_GET_VAL_EX( GetCurrentPositionEx, CursPosX, CursPosY )         /* GDI.470 */
+DC_GET_VAL_EX( GetViewportExtEx, VportExtX, VportExtY )           /* GDI.472 */
+DC_GET_VAL_EX( GetViewportOrgEx, VportOrgX, VportOrgY )           /* GDI.473 */
+DC_GET_VAL_EX( GetWindowExtEx, WndExtX, WndExtY )                 /* GDI.474 */
+DC_GET_VAL_EX( GetWindowOrgEx, WndOrgX, WndOrgY )                 /* GDI.475 */
diff --git a/objects/dib.c b/objects/dib.c
new file mode 100644
index 0000000..839f0b5
--- /dev/null
+++ b/objects/dib.c
@@ -0,0 +1,203 @@
+/*
+ * GDI device independent bitmaps
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include <stdlib.h>
+
+#include "gdi.h"
+
+
+extern XImage * BITMAP_BmpToImage( BITMAP *, void * );
+
+
+/***********************************************************************
+ *           DIB_BitmapInfoSize
+ *
+ * Return the size of the bitmap info structure.
+ */
+int DIB_BitmapInfoSize( BITMAPINFO * info, WORD coloruse )
+{
+    int size = info->bmiHeader.biClrUsed;
+    if (!size && (info->bmiHeader.biBitCount != 24))
+	size = 1 << info->bmiHeader.biBitCount;
+    if (coloruse == DIB_RGB_COLORS) 
+	size = info->bmiHeader.biSize + size * sizeof(RGBQUAD);
+    else
+	size = info->bmiHeader.biSize + size * sizeof(WORD);
+    return size;
+}
+
+
+/***********************************************************************
+ *           DIB_DIBmpToImage
+ *
+ * Create an XImage pointing to the bitmap data.
+ */
+XImage * DIB_DIBmpToImage( BITMAPINFOHEADER * bmp, void * bmpData )
+{
+    XImage * image;
+    int bytesPerLine = (bmp->biWidth * bmp->biBitCount + 31) / 32 * 4;
+    
+    image = XCreateImage( XT_display, DefaultVisualOfScreen( XT_screen ),
+			  bmp->biBitCount, ZPixmap, 0, bmpData,
+			  bmp->biWidth, bmp->biHeight, 32, bytesPerLine );
+    if (!image) return 0;
+    image->byte_order = MSBFirst;
+    image->bitmap_bit_order = MSBFirst;
+    image->bitmap_unit = 16;
+    _XInitImageFuncPtrs(image);
+    return image;
+}
+
+
+/***********************************************************************
+ *           SetDIBits    (GDI.440)
+ */
+int SetDIBits( HDC hdc, HBITMAP hbitmap, WORD startscan, WORD lines,
+	       LPSTR bits, BITMAPINFO * info, WORD coloruse )
+{
+    DC * dc;
+    BITMAPOBJ * bmpObj;
+    BITMAP * bmp;
+    WORD * colorMapping;
+    RGBQUAD * rgbPtr;
+    XImage * bmpImage, * dibImage;
+    int i, x, y, pixel, colors;
+        
+    if (!lines) return 0;
+    if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
+    if (!(bmpObj = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
+	return 0;
+    if (!(bmp = (BITMAP *) GlobalLock( bmpObj->hBitmap ))) return 0;
+
+      /* Build the color mapping table */
+
+    if (info->bmiHeader.biBitCount == 24) colorMapping = NULL;
+    else if (coloruse == DIB_RGB_COLORS)
+    {
+	colors = info->bmiHeader.biClrUsed;
+	if (!colors) colors = 1 << info->bmiHeader.biBitCount;
+	if (!(colorMapping = (WORD *)malloc( colors * sizeof(WORD) )))
+	{
+	    GlobalUnlock( bmpObj->hBitmap );
+	    return 0;
+	}
+	for (i = 0, rgbPtr = info->bmiColors; i < colors; i++, rgbPtr++)
+	    colorMapping[i] = GetNearestPaletteIndex( dc->w.hPalette, 
+						     RGB(rgbPtr->rgbRed,
+							 rgbPtr->rgbGreen,
+							 rgbPtr->rgbBlue) );
+    }
+    else colorMapping = (WORD *)info->bmiColors;
+
+      /* Transfer the pixels (very slow...) */
+
+    bmpImage = BITMAP_BmpToImage( bmp, ((char *)bmp) + sizeof(BITMAP) );
+    dibImage = DIB_DIBmpToImage( &info->bmiHeader, bits );
+
+    for (y = 0; y < lines; y++)
+    {
+	for (x = 0; x < info->bmiHeader.biWidth; x++)
+	{
+	    pixel = XGetPixel( dibImage, x, y );
+	    if (colorMapping) pixel = colorMapping[pixel];
+	    else pixel = GetNearestPaletteIndex(dc->w.hPalette,(COLORREF)pixel);
+	    XPutPixel( bmpImage, x, bmp->bmHeight - startscan - y - 1, pixel );
+	}
+    }
+
+    bmpImage->data = NULL;
+    dibImage->data = NULL;
+    XDestroyImage( bmpImage );
+    XDestroyImage( dibImage );
+
+    if (colorMapping && (coloruse == DIB_RGB_COLORS)) free(colorMapping);
+    
+    GlobalUnlock( bmpObj->hBitmap );
+    return lines;
+}
+
+
+/***********************************************************************
+ *           GetDIBits    (GDI.441)
+ */
+int GetDIBits( HDC hdc, HBITMAP hbitmap, WORD startscan, WORD lines,
+	       LPSTR bits, BITMAPINFO * info, WORD coloruse )
+{
+    DC * dc;
+    BITMAPOBJ * bmpObj;
+    BITMAP * bmp;
+    PALETTEENTRY * palEntry;
+    PALETTEOBJ * palette;
+    XImage * bmpImage, * dibImage;
+    int i, x, y;
+        
+    if (!lines) return 0;
+    if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
+    if (!(bmpObj = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
+	return 0;
+    if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
+	return 0;
+    if (!(bmp = (BITMAP *) GlobalLock( bmpObj->hBitmap ))) return 0;
+
+      /* Transfer color info */
+    
+    palEntry = palette->logpalette.palPalEntry;
+    for (i = 0; i < info->bmiHeader.biClrUsed; i++, palEntry++)
+    {
+	if (coloruse == DIB_RGB_COLORS)
+	{
+	    info->bmiColors[i].rgbRed      = palEntry->peRed;
+	    info->bmiColors[i].rgbGreen    = palEntry->peGreen;
+	    info->bmiColors[i].rgbBlue     = palEntry->peBlue;
+	    info->bmiColors[i].rgbReserved = 0;
+	}
+	else ((WORD *)info->bmiColors)[i] = (WORD)i;
+    }
+    
+      /* Transfer the pixels (very slow...) */
+
+    if (bits)
+    {	
+	bmpImage = BITMAP_BmpToImage( bmp, ((char *)bmp) + sizeof(BITMAP) );
+	dibImage = DIB_DIBmpToImage( &info->bmiHeader, bits );
+
+	for (y = 0; y < lines; y++)
+	{
+	    for (x = 0; x < info->bmiHeader.biWidth; x++)
+	    {
+		XPutPixel( dibImage, x, y,
+		         XGetPixel(bmpImage, x, bmp->bmHeight-startscan-y-1) );
+		
+	    }
+	}
+	
+	bmpImage->data = NULL;
+	dibImage->data = NULL;
+	XDestroyImage( bmpImage );
+	XDestroyImage( dibImage );
+    }
+
+    GlobalUnlock( bmpObj->hBitmap );
+    return lines;
+}
+
+
+/***********************************************************************
+ *           CreateDIBitmap    (GDI.442)
+ */
+HBITMAP CreateDIBitmap( HDC hdc, BITMAPINFOHEADER * header, DWORD init,
+		        LPSTR bits, BITMAPINFO * data, WORD coloruse )
+{
+    HBITMAP handle;
+    
+    handle = CreateCompatibleBitmap( hdc, header->biWidth, header->biHeight );
+    if (!handle) return 0;
+    if (init == CBM_INIT) SetDIBits( hdc, handle, 0, header->biHeight,
+				    bits, data, coloruse );
+    return handle;
+}
diff --git a/objects/font.c b/objects/font.c
new file mode 100644
index 0000000..c30fcec
--- /dev/null
+++ b/objects/font.c
@@ -0,0 +1,332 @@
+/*
+ * GDI font objects
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <X11/Xatom.h>
+#include "gdi.h"
+
+extern Display * XT_display;
+extern Screen * XT_screen;
+
+
+/***********************************************************************
+ *           FONT_MatchFont
+ *
+ * Find a X font matching the logical font.
+ */
+XFontStruct * FONT_MatchFont( DC * dc, LOGFONT * font )
+{
+    char pattern[100];
+    char *family, *weight, *charset;
+    char **names;
+    char slant, spacing;
+    int width, height, count;
+    XFontStruct * fontStruct;
+    
+    weight = (font->lfWeight > 550) ? "bold" : "medium";
+    slant = font->lfItalic ? 'i' : 'r';
+    height = font->lfHeight * 10;
+    width = font->lfWidth * 10;
+    spacing = (font->lfPitchAndFamily & FIXED_PITCH) ? 'm' :
+	      (font->lfPitchAndFamily & VARIABLE_PITCH) ? 'p' : '*';
+    charset = (font->lfCharSet == ANSI_CHARSET) ? "iso8859-1" : "*";
+    family = font->lfFaceName;
+    if (!*family) switch(font->lfPitchAndFamily & 0xf0)
+    {
+      case FF_ROMAN:      family = "times"; break;
+      case FF_SWISS:      family = "helvetica"; break;
+      case FF_MODERN:     family = "courier"; break;
+      case FF_SCRIPT:     family = "*"; break;
+      case FF_DECORATIVE: family = "*"; break;
+      default:            family = "*"; break;
+    }
+    
+    sprintf( pattern, "-*-%s-%s-%c-normal--*-%d-*-*-%c-%d-%s",
+	    family, weight, slant, height, spacing, width, charset );
+#ifdef DEBUG_FONT
+    printf( "FONT_MatchFont: '%s'\n", pattern );
+#endif
+    names = XListFonts( XT_display, pattern, 1, &count );
+    if (!count)
+    {
+#ifdef DEBUG_FONT
+	printf( "        No matching font found\n" );	
+#endif
+	return NULL;
+    }
+#ifdef DEBUG_FONT
+    printf( "        Found '%s'\n", *names );
+#endif
+    fontStruct = XLoadQueryFont( XT_display, *names );
+    XFreeFontNames( names );
+    return fontStruct;
+}
+
+
+/***********************************************************************
+ *           FONT_GetMetrics
+ */
+void FONT_GetMetrics( LOGFONT * logfont, XFontStruct * xfont,
+		      TEXTMETRIC * metrics )
+{    
+    int average, i;
+    unsigned long prop;
+	
+    metrics->tmAscent  = xfont->ascent;
+    metrics->tmDescent = xfont->descent;
+    metrics->tmHeight  = xfont->ascent + xfont->descent;
+
+    metrics->tmInternalLeading  = 0;
+    if (XGetFontProperty( xfont, XA_X_HEIGHT, &prop ))
+	metrics->tmInternalLeading = xfont->ascent - (short)prop;
+    metrics->tmExternalLeading  = 0;
+    metrics->tmMaxCharWidth     = xfont->max_bounds.width;
+    metrics->tmWeight           = logfont->lfWeight;
+    metrics->tmItalic           = logfont->lfItalic;
+    metrics->tmUnderlined       = logfont->lfUnderline;
+    metrics->tmStruckOut        = logfont->lfStrikeOut;
+    metrics->tmFirstChar        = xfont->min_char_or_byte2;
+    metrics->tmLastChar         = xfont->max_char_or_byte2;
+    metrics->tmDefaultChar      = xfont->default_char;
+    metrics->tmBreakChar        = ' ';
+    metrics->tmPitchAndFamily   = logfont->lfPitchAndFamily;
+    metrics->tmCharSet          = logfont->lfCharSet;
+    metrics->tmOverhang         = 0;
+    metrics->tmDigitizedAspectX = 1;
+    metrics->tmDigitizedAspectY = 1;
+
+    if (xfont->per_char) average = metrics->tmMaxCharWidth;
+    else
+    {
+	XCharStruct * charPtr = xfont->per_char;
+	average = 0;
+	for (i = metrics->tmFirstChar; i <= metrics->tmLastChar; i++)
+	{
+	    average += charPtr->width;
+	    charPtr++;
+	}
+	average /= metrics->tmLastChar - metrics->tmFirstChar + 1;
+    }
+    metrics->tmAveCharWidth = average;
+}
+
+
+/***********************************************************************
+ *           CreateFontIndirect    (GDI.57)
+ */
+HFONT CreateFontIndirect( LOGFONT * font )
+{
+    FONTOBJ * fontPtr;
+    HFONT hfont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
+    if (!hfont) return 0;
+    fontPtr = (FONTOBJ *) GDI_HEAP_ADDR( hfont );
+    memcpy( &fontPtr->logfont, font, sizeof(LOGFONT) );
+    return hfont;
+}
+
+
+/***********************************************************************
+ *           CreateFont    (GDI.56)
+ */
+HFONT CreateFont( int height, int width, int esc, int orient, int weight,
+		  BYTE italic, BYTE underline, BYTE strikeout, BYTE charset,
+		  BYTE outpres, BYTE clippres, BYTE quality, BYTE pitch,
+		  LPSTR name )
+{
+    LOGFONT logfont = { height, width, esc, orient, weight, italic, underline,
+		    strikeout, charset, outpres, clippres, quality, pitch, };
+    strncpy( logfont.lfFaceName, name, LF_FACESIZE );
+    return CreateFontIndirect( &logfont );
+}
+
+
+/***********************************************************************
+ *           FONT_GetObject
+ */
+int FONT_GetObject( FONTOBJ * font, int count, LPSTR buffer )
+{
+    if (count > sizeof(LOGFONT)) count = sizeof(LOGFONT);
+    memcpy( buffer, &font->logfont, count );
+    return count;
+}
+
+
+/***********************************************************************
+ *           FONT_SelectObject
+ */
+HFONT FONT_SelectObject( DC * dc, HFONT hfont, FONTOBJ * font )
+{
+    static X_PHYSFONT stockFonts[LAST_STOCK_FONT-FIRST_STOCK_FONT+1];
+    X_PHYSFONT * stockPtr;
+    HFONT prevHandle = dc->w.hFont;
+    XFontStruct * fontStruct;
+
+      /* Load font if necessary */
+
+    if ((hfont >= FIRST_STOCK_FONT) && (hfont <= LAST_STOCK_FONT))
+	stockPtr = &stockFonts[hfont - FIRST_STOCK_FONT];
+    else stockPtr = NULL;
+    
+    if (!stockPtr || !stockPtr->fstruct)
+    {
+	fontStruct = FONT_MatchFont( dc, &font->logfont );
+    }
+    else
+    {
+	fontStruct = stockPtr->fstruct;
+#ifdef DEBUG_FONT
+	printf( "FONT_SelectObject: Loaded font from cache %x %p\n",
+	        hfont, fontStruct );
+#endif
+    }	
+    if (!fontStruct) return 0;
+
+      /* Free previous font */
+
+    if ((prevHandle < FIRST_STOCK_FONT) || (prevHandle > LAST_STOCK_FONT))
+    {
+	if (dc->u.x.font.fstruct)
+	    XFreeFont( XT_display, dc->u.x.font.fstruct );
+    }
+
+      /* Store font */
+
+    dc->w.hFont = hfont;
+    if (stockPtr)
+    {
+	if (!stockPtr->fstruct)
+	{
+	    stockPtr->fstruct = fontStruct;
+	    FONT_GetMetrics( &font->logfont, fontStruct, &stockPtr->metrics );
+	}
+	memcpy( &dc->u.x.font, stockPtr, sizeof(*stockPtr) );
+    }
+    else
+    {
+	dc->u.x.font.fstruct = fontStruct;
+	FONT_GetMetrics( &font->logfont, fontStruct, &dc->u.x.font.metrics );
+    }
+    return prevHandle;
+}
+
+
+/***********************************************************************
+ *           GetTextCharacterExtra    (GDI.89)
+ */
+short GetTextCharacterExtra( HDC hdc )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return 0;
+    return abs( (dc->w.charExtra * dc->w.WndExtX + dc->w.VportExtX / 2)
+	         / dc->w.VportExtX );
+}
+
+
+/***********************************************************************
+ *           SetTextCharacterExtra    (GDI.8)
+ */
+short SetTextCharacterExtra( HDC hdc, short extra )
+{
+    short prev;
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return 0;
+    extra = (extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX;    
+    prev = dc->w.charExtra;
+    dc->w.charExtra = abs(extra);
+    return (prev * dc->w.WndExtX + dc->w.VportExtX / 2) / dc->w.VportExtX;
+}
+
+
+/***********************************************************************
+ *           SetTextJustification    (GDI.10)
+ */
+short SetTextJustification( HDC hdc, short extra, short breaks )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return 0;
+
+    extra = abs((extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX);
+    if (!extra) breaks = 0;
+    dc->w.breakTotalExtra = extra;
+    dc->w.breakCount = breaks;
+    if (breaks)
+    {	
+	dc->w.breakExtra = extra / breaks;
+	dc->w.breakRem   = extra - (dc->w.breakCount * dc->w.breakExtra);
+    }
+    else
+    {
+	dc->w.breakExtra = 0;
+	dc->w.breakRem   = 0;
+    }
+    return 1;
+}
+
+
+/***********************************************************************
+ *           GetTextExtent    (GDI.91)
+ */
+DWORD GetTextExtent( HDC hdc, LPSTR str, short count )
+{
+    SIZE size;
+    if (!GetTextExtentPoint( hdc, str, count, &size )) return 0;
+    return size.cx | (size.cy << 16);
+}
+
+
+/***********************************************************************
+ *           GetTextExtentPoint    (GDI.471)
+ */
+BOOL GetTextExtentPoint( HDC hdc, LPSTR str, short count, LPSIZE size )
+{
+    int dir, ascent, descent;
+    XCharStruct info;
+
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return FALSE;
+    XTextExtents( dc->u.x.font.fstruct, str, count, &dir,
+		  &ascent, &descent, &info );
+    size->cx = abs((info.width + dc->w.breakRem + count * dc->w.charExtra)
+		    * dc->w.WndExtX / dc->w.VportExtX);
+    size->cy = abs((dc->u.x.font.fstruct->ascent+dc->u.x.font.fstruct->descent)
+		    * dc->w.WndExtY / dc->w.VportExtY);
+
+#ifdef DEBUG_FONT
+    printf( "GetTextExtentPoint(%d '%s' %d %p): returning %d,%d\n",
+	    hdc, str, count, size, size->cx, size->cy );
+#endif
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           GetTextMetrics    (GDI.93)
+ */
+BOOL GetTextMetrics( HDC hdc, LPTEXTMETRIC metrics )
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return FALSE;
+    memcpy( metrics, &dc->u.x.font.metrics, sizeof(*metrics) );
+
+    metrics->tmAscent  = abs( metrics->tmAscent
+			      * dc->w.WndExtY / dc->w.VportExtY );
+    metrics->tmDescent = abs( metrics->tmDescent
+			      * dc->w.WndExtY / dc->w.VportExtY );
+    metrics->tmHeight  = metrics->tmAscent + metrics->tmDescent;
+    metrics->tmInternalLeading = abs( metrics->tmInternalLeading
+				      * dc->w.WndExtY / dc->w.VportExtY );
+    metrics->tmExternalLeading = abs( metrics->tmExternalLeading
+				      * dc->w.WndExtY / dc->w.VportExtY );
+    metrics->tmMaxCharWidth    = abs( metrics->tmMaxCharWidth 
+				      * dc->w.WndExtX / dc->w.VportExtX );
+    metrics->tmAveCharWidth    = abs( metrics->tmAveCharWidth
+				      * dc->w.WndExtX / dc->w.VportExtX );
+    return TRUE;
+}
+
diff --git a/objects/gdiobj.c b/objects/gdiobj.c
new file mode 100644
index 0000000..55237c3
--- /dev/null
+++ b/objects/gdiobj.c
@@ -0,0 +1,380 @@
+/*
+ * GDI functions
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include "gdi.h"
+
+extern Display * XT_display;
+extern Screen * XT_screen;
+
+MDESC *GDI_Heap = NULL;
+
+
+/***********************************************************************
+ *          GDI stock objects 
+ */
+
+static BRUSHOBJ WhiteBrush =
+{
+    { 0, BRUSH_MAGIC, 1, 0 },          /* header */
+    { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
+};
+
+static BRUSHOBJ LtGrayBrush =
+{
+    { 0, BRUSH_MAGIC, 1, 0 },          /* header */
+    { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
+};
+
+static BRUSHOBJ GrayBrush =
+{
+    { 0, BRUSH_MAGIC, 1, 0 },          /* header */
+    { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
+};
+
+static BRUSHOBJ DkGrayBrush =
+{
+    { 0, BRUSH_MAGIC, 1, 0 },       /* header */
+    { BS_SOLID, RGB(64,64,64), 0 }  /* logbrush */
+};
+
+static BRUSHOBJ BlackBrush =
+{
+    { 0, BRUSH_MAGIC, 1, 0 },    /* header */
+    { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
+};
+
+static BRUSHOBJ NullBrush =
+{
+    { 0, BRUSH_MAGIC, 1, 0 },  /* header */
+    { BS_NULL, 0, 0 }          /* logbrush */
+};
+
+static PENOBJ WhitePen =
+{
+    { 0, PEN_MAGIC, 1, 0 },                  /* header */
+    { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
+};
+
+static PENOBJ BlackPen =
+{
+    { 0, PEN_MAGIC, 1, 0 },            /* header */
+    { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
+};
+
+static PENOBJ NullPen =
+{
+    { 0, PEN_MAGIC, 1, 0 },   /* header */
+    { PS_NULL, { 1, 0 }, 0 }  /* logpen */
+};
+
+static FONTOBJ OEMFixedFont =
+{
+    { 0, FONT_MAGIC, 1, 0 },   /* header */
+    { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
+      0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
+};
+
+static FONTOBJ AnsiFixedFont =
+{
+    { 0, FONT_MAGIC, 1, 0 },   /* header */
+    { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
+      0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
+};
+
+static FONTOBJ AnsiVarFont =
+{
+    { 0, FONT_MAGIC, 1, 0 },   /* header */
+    { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
+      0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
+};
+
+static FONTOBJ SystemFont =
+{
+    { 0, FONT_MAGIC, 1, 0 },   /* header */
+    { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
+      0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
+};
+
+static FONTOBJ DeviceDefaultFont =
+{
+    { 0, FONT_MAGIC, 1, 0 },   /* header */
+    { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
+      0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
+};
+
+static FONTOBJ SystemFixedFont =
+{
+    { 0, FONT_MAGIC, 1, 0 },   /* header */
+    { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
+      0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
+};
+
+
+static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
+{
+    (GDIOBJHDR *) &WhiteBrush,
+    (GDIOBJHDR *) &LtGrayBrush,
+    (GDIOBJHDR *) &GrayBrush,
+    (GDIOBJHDR *) &DkGrayBrush,
+    (GDIOBJHDR *) &BlackBrush,
+    (GDIOBJHDR *) &NullBrush,
+    (GDIOBJHDR *) &WhitePen,
+    (GDIOBJHDR *) &BlackPen,
+    (GDIOBJHDR *) &NullPen,
+    NULL,
+    (GDIOBJHDR *) &OEMFixedFont,
+    (GDIOBJHDR *) &AnsiFixedFont,
+    (GDIOBJHDR *) &AnsiVarFont,
+    (GDIOBJHDR *) &SystemFont,
+    (GDIOBJHDR *) &DeviceDefaultFont,
+    NULL,            /* DEFAULT_PALETTE created by PALETTE_Init */
+    (GDIOBJHDR *) &SystemFixedFont
+};
+
+extern GDIOBJHDR * PALETTE_systemPalette;
+
+
+/***********************************************************************
+ *           GDI_Init
+ *
+ * GDI initialisation.
+ */
+BOOL GDI_Init()
+{
+    struct segment_descriptor_s * s;
+
+      /* Create GDI heap */
+
+    s = GetNextSegment( 0, 0x10000 );
+    if (s == NULL) return FALSE;
+    HEAP_Init( &GDI_Heap, s->base_addr, GDI_HEAP_SIZE );
+    free(s);
+
+      /* Create default palette */
+
+    PALETTE_Init();
+    StockObjects[DEFAULT_PALETTE] = PALETTE_systemPalette;
+
+      /* Create default bitmap */
+
+    if (!BITMAP_Init()) return FALSE;
+
+      /* Initialise regions */
+
+    if (!REGION_Init()) return FALSE;
+    
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           GDI_FindPrevObject
+ *
+ * Return the GDI object whose hNext field points to obj.
+ */
+HANDLE GDI_FindPrevObject( HANDLE first, HANDLE obj )
+{
+    HANDLE handle;
+        
+    for (handle = first; handle && (handle != obj); )
+    {
+	GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
+	handle = header->hNext;
+    }
+    return handle;
+}
+
+
+/***********************************************************************
+ *           GDI_AllocObject
+ */
+HANDLE GDI_AllocObject( WORD size, WORD magic )
+{
+    static DWORD count = 0;
+    GDIOBJHDR * obj;
+    HANDLE handle = GDI_HEAP_ALLOC( GMEM_MOVEABLE, size );
+    if (!handle) return 0;
+    
+    obj = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
+    obj->hNext   = 0;
+    obj->wMagic  = magic;
+    obj->dwCount = ++count;
+    return handle;
+}
+
+
+/***********************************************************************
+ *           GDI_FreeObject
+ */
+BOOL GDI_FreeObject( HANDLE handle )
+{
+    GDIOBJHDR * object;
+    HANDLE prev;
+
+      /* Can't free stock objects */
+    if (handle >= FIRST_STOCK_HANDLE) return FALSE;
+    
+    object = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
+    if (!object) return FALSE;
+
+      /* Free object */
+    
+    GDI_HEAP_FREE( handle );
+    return TRUE;
+}
+
+/***********************************************************************
+ *           GDI_GetObjPtr
+ *
+ * Return a pointer to the GDI object associated to the handle.
+ * Return NULL if the object has the wrong magic number.
+ */
+GDIOBJHDR * GDI_GetObjPtr( HANDLE handle, WORD magic )
+{
+    GDIOBJHDR * ptr = NULL;
+
+    if (handle >= FIRST_STOCK_HANDLE)
+    {
+	if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
+	    ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
+    }
+    else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
+    if (!ptr) return NULL;
+    if (ptr->wMagic != magic) return NULL;
+    return ptr;
+}
+
+
+/***********************************************************************
+ *           DeleteObject    (GDI.69)
+ */
+BOOL DeleteObject( HANDLE obj )
+{
+      /* Check if object is valid */
+
+    GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_ADDR( obj );
+    if (!header) return FALSE;
+
+#ifdef DEBUG_GDI
+    printf( "DeleteObject: %d\n", obj );
+#endif
+
+      /* Delete object */
+
+    switch(header->wMagic)
+    {
+      case PEN_MAGIC:     return GDI_FreeObject( obj );
+      case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, header );
+      case FONT_MAGIC:    return GDI_FreeObject( obj );
+      case PALETTE_MAGIC: return GDI_FreeObject( obj );
+      case BITMAP_MAGIC:  return BMP_DeleteObject( obj, header );
+      case REGION_MAGIC:  return REGION_DeleteObject( obj, header );
+    }
+    return FALSE;
+}
+
+
+/***********************************************************************
+ *           GetStockObject    (GDI.87)
+ */
+HANDLE GetStockObject( int obj )
+{
+    if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
+    if (!StockObjects[obj]) return 0;
+#ifdef DEBUG_GDI
+    printf( "GetStockObject: returning %04x\n", FIRST_STOCK_HANDLE + obj );
+#endif
+    return FIRST_STOCK_HANDLE + obj;
+}
+
+
+/***********************************************************************
+ *           GetObject    (GDI.82)
+ */
+int GetObject( HANDLE handle, int count, LPSTR buffer )
+{
+    GDIOBJHDR * ptr = NULL;
+#ifdef DEBUG_GDI
+    printf( "GetObject: %04x %d %08x\n", handle, count, buffer );
+#endif
+    if (!count) return 0;
+
+    if (handle >= FIRST_STOCK_HANDLE)
+    {
+	if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
+	    ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
+    }
+    else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
+    if (!ptr) return 0;
+    
+    switch(ptr->wMagic)
+    {
+      case PEN_MAGIC:
+	  return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
+      case BRUSH_MAGIC: 
+	  return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
+      case BITMAP_MAGIC: 
+	  return BMP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
+      case FONT_MAGIC:
+	  return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
+      case PALETTE_MAGIC:
+	  return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
+    }
+    return 0;
+}
+
+
+/***********************************************************************
+ *           SelectObject    (GDI.45)
+ */
+HANDLE SelectObject( HDC hdc, HANDLE handle )
+{
+    GDIOBJHDR * ptr = NULL;
+    DC * dc;
+    
+#ifdef DEBUG_GDI
+    printf( "SelectObject: %d %04x\n", hdc, handle );
+#endif
+    if (handle >= FIRST_STOCK_HANDLE)
+    {
+	if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
+	    ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
+    }
+    else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
+    if (!ptr) return 0;
+    
+    dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return 0;
+    
+    switch(ptr->wMagic)
+    {
+      case PEN_MAGIC:
+	  return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
+      case BRUSH_MAGIC:
+	  return BRUSH_SelectObject( hdc, dc, handle, (BRUSHOBJ *)ptr );
+      case BITMAP_MAGIC:
+	  return BITMAP_SelectObject( hdc, dc, handle, (BITMAPOBJ *)ptr );
+      case FONT_MAGIC:
+	  return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );	  
+      case REGION_MAGIC:
+	  return SelectClipRgn( hdc, handle );
+    }
+    return 0;
+}
+
+
+/***********************************************************************
+ *           UnrealizeObject    (GDI.150)
+ */
+BOOL UnrealizeObject( HANDLE handle )
+{
+#ifdef DEBUG_GDI
+    printf( "UnrealizeObject: %04x\n", handle );
+#endif
+    return TRUE;
+}
diff --git a/objects/linedda.c b/objects/linedda.c
new file mode 100644
index 0000000..f95ea48
--- /dev/null
+++ b/objects/linedda.c
@@ -0,0 +1,19 @@
+/*
+ * LineDDA
+ *
+ * Copyright 1993 Bob Amstadt
+ */
+
+static char Copyright[] = "Copyright  Bob Amstadt, 1993";
+
+#include <X11/Intrinsic.h>
+#include <X11/StringDefs.h>
+#include "win.h"
+
+/**********************************************************************
+ *		LineDDA		(GDI.100)
+ */
+void LineDDA(short nXStart, short nYStart, short nXEnd, short nYEnd,
+	     FARPROC callback, long lParam)
+{
+}
diff --git a/objects/palette.c b/objects/palette.c
new file mode 100644
index 0000000..bdde29d
--- /dev/null
+++ b/objects/palette.c
@@ -0,0 +1,191 @@
+/*
+ * GDI palette objects
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include <stdlib.h>
+#include <values.h>
+#include <X11/Xlib.h>
+
+#include "gdi.h"
+
+extern Display * XT_display;
+extern Screen * XT_screen;
+
+
+#define NB_RESERVED_COLORS  17
+static char * ReservedColors[NB_RESERVED_COLORS] =
+{
+    "black",
+    "gray25",
+    "gray50",
+    "gray75",
+    "white",
+    "red1",
+    "red4",
+    "green1",
+    "green4",
+    "blue1",
+    "blue4",
+    "cyan1",
+    "cyan4",
+    "magenta1",
+    "magenta4",
+    "yellow1",
+    "yellow4"
+};
+
+GDIOBJHDR * PALETTE_systemPalette;
+
+static int SysColorPixels[NB_RESERVED_COLORS];
+
+
+/***********************************************************************
+ *           PALETTE_Init
+ */
+BOOL PALETTE_Init()
+{
+    int i, size, pixel;
+    XColor serverColor, exactColor;
+    HPALETTE hpalette;
+    LOGPALETTE * palPtr;
+
+    size = DefaultVisual(XT_display,DefaultScreen(XT_display))->map_entries;
+    palPtr = malloc( sizeof(LOGPALETTE) + (size-1)*sizeof(PALETTEENTRY) );
+    if (!palPtr) return FALSE;
+    palPtr->palVersion = 0x300;
+    palPtr->palNumEntries = size;
+    memset( palPtr->palPalEntry, 0xff, size*sizeof(PALETTEENTRY) );
+    
+    for (i = 0; i < NB_RESERVED_COLORS; i++)
+    {
+	if (XAllocNamedColor( XT_display,
+			      DefaultColormapOfScreen( XT_screen ),
+			      ReservedColors[i], 
+			      &serverColor, &exactColor ))
+	{
+	    pixel = serverColor.pixel;
+	    palPtr->palPalEntry[pixel].peRed   = serverColor.red >> 8;
+	    palPtr->palPalEntry[pixel].peGreen = serverColor.green >> 8;
+	    palPtr->palPalEntry[pixel].peBlue  = serverColor.blue >> 8;
+	    palPtr->palPalEntry[pixel].peFlags = 0;
+	}
+    }
+    hpalette = CreatePalette( palPtr );
+    PALETTE_systemPalette = (GDIOBJHDR *) GDI_HEAP_ADDR( hpalette );
+    free( palPtr );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           CreatePalette    (GDI.360)
+ */
+HPALETTE CreatePalette( LOGPALETTE * palette )
+{
+    PALETTEOBJ * palettePtr;
+    HPALETTE hpalette;
+    int size;
+
+    size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
+    hpalette = GDI_AllocObject( sizeof(GDIOBJHDR) + size, PALETTE_MAGIC );
+    if (!hpalette) return 0;
+    palettePtr = (PALETTEOBJ *) GDI_HEAP_ADDR( hpalette );
+    memcpy( &palettePtr->logpalette, palette, size );
+    return hpalette;
+}
+
+
+/***********************************************************************
+ *           GetPaletteEntries    (GDI.363)
+ */
+WORD GetPaletteEntries( HPALETTE hpalette, WORD start, WORD count,
+		        LPPALETTEENTRY entries )
+{
+    PALETTEOBJ * palPtr;
+    int numEntries;
+        
+    palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
+    if (!palPtr) return 0;
+    numEntries = palPtr->logpalette.palNumEntries;
+    if (start >= numEntries) return 0;
+    if (start+count > numEntries) count = numEntries - start;
+    memcpy( entries, &palPtr->logpalette.palPalEntry[start],
+	    count * sizeof(PALETTEENTRY) );
+    return count;
+}
+
+
+/***********************************************************************
+ *           SetPaletteEntries    (GDI.364)
+ */
+WORD SetPaletteEntries( HPALETTE hpalette, WORD start, WORD count,
+		        LPPALETTEENTRY entries )
+{
+    PALETTEOBJ * palPtr;
+    int numEntries;
+        
+    palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
+    if (!palPtr) return 0;
+    numEntries = palPtr->logpalette.palNumEntries;
+    if (start >= numEntries) return 0;
+    if (start+count > numEntries) count = numEntries - start;
+    memcpy( &palPtr->logpalette.palPalEntry[start], entries,
+	    count * sizeof(PALETTEENTRY) );
+    return count;
+}
+
+
+/***********************************************************************
+ *           GetNearestPaletteIndex    (GDI.370)
+ */
+WORD GetNearestPaletteIndex( HPALETTE hpalette, COLORREF color )
+{
+    int i, minDist, dist;
+    WORD index = 0;
+    BYTE r, g, b;
+    PALETTEENTRY * entry;
+    PALETTEOBJ * palPtr;
+    
+    palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
+    if (!palPtr) return 0;
+    
+    r = GetRValue(color);
+    g = GetGValue(color);
+    b = GetBValue(color);
+    entry = palPtr->logpalette.palPalEntry;
+    for (i = 0, minDist = MAXINT; i < palPtr->logpalette.palNumEntries; i++)
+    {
+	if (entry->peFlags != 0xff)
+	{
+	    dist = (r - entry->peRed) * (r - entry->peRed) +
+		   (g - entry->peGreen) * (g - entry->peGreen) +
+		   (b - entry->peBlue) * (b - entry->peBlue);	
+	    if (dist < minDist)
+	    {
+		minDist = dist;
+		index = i;
+	    }
+	}
+	entry++;
+    }
+#ifdef DEBUG_GDI
+    printf( "GetNearestPaletteIndex(%x,%06x) : returning %d\n", 
+	     hpalette, color, index );
+#endif
+    return index;
+}
+
+
+/***********************************************************************
+ *           PALETTE_GetObject
+ */
+int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer )
+{
+    if (count > sizeof(WORD)) count = sizeof(WORD);
+    memcpy( buffer, &palette->logpalette.palNumEntries, count );
+    return count;
+}
diff --git a/objects/pen.c b/objects/pen.c
new file mode 100644
index 0000000..fa49ef3
--- /dev/null
+++ b/objects/pen.c
@@ -0,0 +1,93 @@
+/*
+ * GDI pen objects
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include "gdi.h"
+
+extern Display * XT_display;
+extern Screen * XT_screen;
+
+
+/***********************************************************************
+ *           CreatePen    (GDI.61)
+ */
+HPEN CreatePen( short style, short width, COLORREF color )
+{
+    LOGPEN logpen = { style, { width, 0 }, color };
+#ifdef DEBUG_GDI
+    printf( "CreatePen: %d %d %06x\n", style, width, color );
+#endif
+    return CreatePenIndirect( &logpen );
+}
+
+
+/***********************************************************************
+ *           CreatePenIndirect    (GDI.62)
+ */
+HPEN CreatePenIndirect( LOGPEN * pen )
+{
+    PENOBJ * penPtr;
+    HPEN hpen;
+
+    if (pen->lopnStyle > PS_INSIDEFRAME) return 0;
+    hpen = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC );
+    if (!hpen) return 0;
+    penPtr = (PENOBJ *) GDI_HEAP_ADDR( hpen );    
+    memcpy( &penPtr->logpen, pen, sizeof(LOGPEN) );
+    return hpen;
+}
+
+
+/***********************************************************************
+ *           PEN_GetObject
+ */
+int PEN_GetObject( PENOBJ * pen, int count, LPSTR buffer )
+{
+    if (count > sizeof(LOGPEN)) count = sizeof(LOGPEN);
+    memcpy( buffer, &pen->logpen, count );
+    return count;
+}
+
+
+/***********************************************************************
+ *           PEN_SelectObject
+ */
+HPEN PEN_SelectObject( DC * dc, HPEN hpen, PENOBJ * pen )
+{
+    static char dash_dash[]       = { 5, 3 };      /* -----   -----   -----  */
+    static char dash_dot[]        = { 2, 2 };      /* --  --  --  --  --  -- */
+    static char dash_dashdot[]    = { 4,3,2,3 };   /* ----   --   ----   --  */
+    static char dash_dashdotdot[] = { 4,2,2,2,2,2 };  /* ----  --  --  ----  */
+
+    HPEN prevHandle = dc->w.hPen;
+    dc->w.hPen = hpen;
+
+    dc->u.x.pen.style = pen->logpen.lopnStyle;
+    dc->u.x.pen.width = pen->logpen.lopnWidth.x * dc->w.VportExtX
+	                  / dc->w.WndExtX;
+    if (dc->u.x.pen.width < 0) dc->u.x.pen.width = -dc->u.x.pen.width;
+    if (dc->u.x.pen.width == 1) dc->u.x.pen.width = 0;  /* Faster */
+    dc->u.x.pen.pixel = GetNearestPaletteIndex( dc->w.hPalette,
+					        pen->logpen.lopnColor );    
+    switch(pen->logpen.lopnStyle)
+    {
+      case PS_DASH:
+	XSetDashes( XT_display, dc->u.x.gc, 0, dash_dash, 2 );
+	break;
+      case PS_DOT:
+	XSetDashes( XT_display, dc->u.x.gc, 0, dash_dot, 2 );
+	break;
+      case PS_DASHDOT:
+	XSetDashes( XT_display, dc->u.x.gc, 0, dash_dashdot, 4 );
+	break;
+      case PS_DASHDOTDOT:
+	XSetDashes( XT_display, dc->u.x.gc, 0, dash_dashdotdot, 6 );
+	break;
+    }
+    
+    return prevHandle;
+}
diff --git a/objects/region.c b/objects/region.c
new file mode 100644
index 0000000..2c22ee4
--- /dev/null
+++ b/objects/region.c
@@ -0,0 +1,614 @@
+/*
+ * GDI region objects
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "gdi.h"
+
+
+  /* GC used for region operations */
+static GC regionGC = 0;
+
+
+/***********************************************************************
+ *           REGION_Init
+ */
+BOOL REGION_Init()
+{
+    Pixmap tmpPixmap;
+
+      /* CreateGC needs a drawable */
+    tmpPixmap = XCreatePixmap( XT_display, DefaultRootWindow(XT_display),
+			       1, 1, 1 );
+    if (tmpPixmap)
+    {
+	regionGC = XCreateGC( XT_display, tmpPixmap, 0, NULL );
+	XFreePixmap( XT_display, tmpPixmap );
+	if (!regionGC) return FALSE;
+	XSetForeground( XT_display, regionGC, 1 );
+	return TRUE;
+    }
+    else return FALSE;
+}
+
+
+/***********************************************************************
+ *           REGION_SetRect
+ *
+ * Set the bounding box of the region and create the pixmap.
+ * The hrgn must be valid.
+ */
+static BOOL REGION_SetRect( HRGN hrgn, LPRECT rect )
+{
+    int width, height;
+
+      /* Fill region */
+
+    REGION * region = &((RGNOBJ *)GDI_HEAP_ADDR( hrgn ))->region;
+    width  = rect->right - rect->left;
+    height = rect->bottom - rect->top;
+    if ((width <= 0) || (height <= 0))
+    {
+	region->type       = NULLREGION;
+	region->box.left   = 0;
+	region->box.right  = 0;
+	region->box.top    = 0;
+	region->box.bottom = 0;
+	region->pixmap     = 0;
+	return TRUE;
+    }
+    region->type = SIMPLEREGION;
+    region->box  = *rect;
+    
+      /* Create pixmap */
+
+    region->pixmap = XCreatePixmap( XT_display, DefaultRootWindow(XT_display),
+				    width, height, 1 );
+    if (!region->pixmap) return FALSE;
+
+      /* Fill pixmap */
+
+    XSetFunction( XT_display, regionGC, GXclear );
+    XFillRectangle( XT_display, region->pixmap, regionGC,
+		    0, 0, width, height );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           REGION_DeleteObject
+ */
+BOOL REGION_DeleteObject( HRGN hrgn, RGNOBJ * obj )
+{
+    if (obj->region.pixmap) XFreePixmap( XT_display, obj->region.pixmap );
+    return GDI_FreeObject( hrgn );
+}
+
+
+/***********************************************************************
+ *           OffsetRgn    (GDI.101)
+ */
+int OffsetRgn( HRGN hrgn, short x, short y )
+{
+    RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
+    if (!obj) return ERROR;
+#ifdef DEBUG_REGION
+    printf( "OffsetRgn: %d %d,%d\n", hrgn, x, y );
+#endif
+    OffsetRect( &obj->region.box, x, y );
+    return obj->region.type;
+}
+
+
+/***********************************************************************
+ *           GetRgnBox    (GDI.134)
+ */
+int GetRgnBox( HRGN hrgn, LPRECT rect )
+{
+    RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
+    if (!obj) return ERROR;
+#ifdef DEBUG_REGION
+    printf( "GetRgnBox: %d\n", hrgn );
+#endif
+    *rect = obj->region.box;
+    return obj->region.type;
+}
+
+
+/***********************************************************************
+ *           CreateRectRgn    (GDI.64)
+ */
+HRGN CreateRectRgn( short left, short top, short right, short bottom )
+{
+    RECT rect = { left, top, right, bottom };    
+    return CreateRectRgnIndirect( &rect );
+}
+
+
+/***********************************************************************
+ *           CreateRectRgnIndirect    (GDI.65)
+ */
+HRGN CreateRectRgnIndirect( LPRECT rect )
+{
+    RGNOBJ * rgnObj;
+    HRGN hrgn;
+
+#ifdef DEBUG_REGION
+    printf( "CreateRectRgnIndirect: %d,%d-%d,%d\n",
+	    rect->left, rect->top, rect->right, rect->bottom );
+#endif
+    
+      /* Create region */
+
+    if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
+    if (!REGION_SetRect( hrgn, rect ))
+    {
+	GDI_FreeObject( hrgn );
+	return 0;
+    }
+    rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
+
+      /* Fill pixmap */
+    
+    if (rgnObj->region.type != NULLREGION)
+    {
+	int width  = rgnObj->region.box.right - rgnObj->region.box.left;
+	int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
+	XSetFunction( XT_display, regionGC, GXcopy );
+	XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
+		        0, 0, width, height );
+    }
+    
+    return hrgn;
+}
+
+
+/***********************************************************************
+ *           CreateRoundRectRgn    (GDI.444)
+ */
+HRGN CreateRoundRectRgn( short left, short top, short right, short bottom,
+			 short ellipse_width, short ellipse_height )
+{
+    RECT rect = { left, top, right, bottom };    
+    RGNOBJ * rgnObj;
+    HRGN hrgn;
+
+#ifdef DEBUG_REGION
+    printf( "CreateRoundRectRgn: %d,%d-%d,%d %dx%d\n",
+	    left, top, right, bottom, ellipse_width, ellipse_height );
+#endif
+    
+      /* Create region */
+
+    if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
+    if (!REGION_SetRect( hrgn, &rect ))
+    {
+	GDI_FreeObject( hrgn );
+	return 0;
+    }
+    rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
+
+      /* Fill pixmap */
+    
+    if (rgnObj->region.type != NULLREGION)
+    {
+	int width  = rgnObj->region.box.right - rgnObj->region.box.left;
+	int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
+	XSetFunction( XT_display, regionGC, GXcopy );
+	XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
+		        0, ellipse_height / 2,
+		        width, height - ellipse_height );
+	XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
+		        ellipse_width / 2, 0,
+		        width - ellipse_width, height );
+	XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
+		  0, 0,
+		  ellipse_width, ellipse_height, 0, 360*64 );
+	XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
+		  width - ellipse_width, 0,
+		  ellipse_width, ellipse_height, 0, 360*64 );
+	XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
+		  0, height - ellipse_height,
+		  ellipse_width, ellipse_height, 0, 360*64 );
+	XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
+		  width - ellipse_width, height - ellipse_height,
+		  ellipse_width, ellipse_height, 0, 360*64 );
+    }
+    
+    return hrgn;
+}
+
+
+/***********************************************************************
+ *           SetRectRgn    (GDI.172)
+ */
+void SetRectRgn( HRGN hrgn, short left, short top, short right, short bottom )
+{
+    RECT rect = { left, top, right, bottom };    
+    RGNOBJ * rgnObj;
+
+#ifdef DEBUG_REGION
+    printf( "SetRectRgn: %d %d,%d-%d,%d\n", hrgn, left, top, right, bottom );
+#endif
+    
+      /* Free previous pixmap */
+
+    if (!(rgnObj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return;
+    if (rgnObj->region.pixmap) 
+	XFreePixmap( XT_display, rgnObj->region.pixmap );
+
+    if (!REGION_SetRect( hrgn, &rect )) return;
+
+      /* Fill pixmap */
+    
+    if (rgnObj->region.type != NULLREGION)
+    {
+	int width  = rgnObj->region.box.right - rgnObj->region.box.left;
+	int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
+	XSetFunction( XT_display, regionGC, GXcopy );
+	XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
+		        0, 0, width, height );
+    }
+}
+
+
+/***********************************************************************
+ *           CreateEllipticRgn    (GDI.54)
+ */
+HRGN CreateEllipticRgn( short left, short top, short right, short bottom )
+{
+    RECT rect = { left, top, right, bottom };    
+    return CreateEllipticRgnIndirect( &rect );
+}
+
+
+/***********************************************************************
+ *           CreateEllipticRgnIndirect    (GDI.55)
+ */
+HRGN CreateEllipticRgnIndirect( LPRECT rect )
+{
+    RGNOBJ * rgnObj;
+    HRGN hrgn;
+
+#ifdef DEBUG_REGION
+    printf( "CreateEllipticRgnIndirect: %d,%d-%d,%d\n",
+	    rect->left, rect->top, rect->right, rect->bottom );
+#endif
+    
+      /* Create region */
+
+    if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
+    if (!REGION_SetRect( hrgn, rect ))
+    {
+	GDI_FreeObject( hrgn );
+	return 0;
+    }
+    rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
+
+      /* Fill pixmap */
+    
+    if (rgnObj->region.type != NULLREGION)
+    {
+	int width  = rgnObj->region.box.right - rgnObj->region.box.left;
+	int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
+	XSetFunction( XT_display, regionGC, GXcopy );
+	XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
+		  0, 0, width, height, 0, 360*64 );
+    }
+    
+    return hrgn;
+}
+
+
+/***********************************************************************
+ *           CreatePolygonRgn    (GDI.63)
+ */
+HRGN CreatePolygonRgn( POINT * points, short count, short mode )
+{
+    return CreatePolyPolygonRgn( points, &count, 1, mode );
+}
+
+
+/***********************************************************************
+ *           CreatePolyPolygonRgn    (GDI.451)
+ */
+HRGN CreatePolyPolygonRgn( POINT * points, short * count,
+			   short nbpolygons, short mode )
+{
+    RGNOBJ * rgnObj;
+    HRGN hrgn;
+    RECT box;
+    int i, j, totalPoints;
+    POINT * pt;
+    XPoint * xpoints;
+    
+    if (!nbpolygons) return 0;
+#ifdef DEBUG_REGION
+    printf( "CreatePolyPolygonRgn: %d polygons\n", nbpolygons );
+#endif
+    
+      /* Find bounding box */
+
+    box.top   = box.left   = 32767;
+    box.right = box.bottom = 0;
+    for (i = totalPoints = 0, pt = points; i < nbpolygons; i++)
+    {
+	totalPoints += count[i];
+	for (j = 0; j < count[i]; j++, pt++)
+	{
+	    if (pt->x < box.left) box.left = pt->x;
+	    if (pt->x > box.right) box.right = pt->x;
+	    if (pt->y < box.top) box.top = pt->y;
+	    if (pt->y > box.bottom) box.bottom = pt->y;
+	}
+    }        
+    if (!totalPoints) return 0;
+    
+      /* Build points array */
+
+    xpoints = (XPoint *) malloc( sizeof(XPoint) * totalPoints );
+    if (!xpoints) return 0;
+    for (i = 0, pt = points; i < totalPoints; i++, pt++)
+    {
+	xpoints[i].x = pt->x - box.left;
+	xpoints[i].y = pt->y - box.top;
+    }
+
+      /* Create region */
+
+    if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC )) ||
+	!REGION_SetRect( hrgn, &box ))
+    {
+	if (hrgn) GDI_FreeObject( hrgn );
+	free( xpoints );
+	return 0;
+    }
+    rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
+
+      /* Fill pixmap */
+
+    if (rgnObj->region.type != NULLREGION)
+    {
+	XSetFunction( XT_display, regionGC, GXcopy );
+	if (mode == WINDING) XSetFillRule( XT_display, regionGC, WindingRule );
+	else XSetFillRule( XT_display, regionGC, EvenOddRule );
+	for (i = j = 0; i < nbpolygons; i++)
+	{
+	    XFillPolygon( XT_display, rgnObj->region.pixmap, regionGC,
+			  &xpoints[j], count[i], Complex, CoordModeOrigin );
+	    j += count[i];
+	}
+    }
+    
+    free( xpoints );
+    return hrgn;
+}
+
+
+/***********************************************************************
+ *           PtInRegion    (GDI.161)
+ */
+BOOL PtInRegion( HRGN hrgn, short x, short y )
+{
+    XImage * image;
+    BOOL res;
+    RGNOBJ * obj;
+    POINT pt = { x, y };
+    
+    if (!(obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return FALSE;
+    if (!PtInRect( &obj->region.box, pt )) return FALSE;
+    image = XGetImage( XT_display, obj->region.pixmap,
+		       x - obj->region.box.left, y - obj->region.box.top,
+		       1, 1, AllPlanes, ZPixmap );
+    if (!image) return FALSE;
+    res = (XGetPixel( image, 0, 0 ) != 0);
+    XDestroyImage( image );
+    return res;
+}
+
+
+/***********************************************************************
+ *           RectInRegion    (GDI.181)
+ */
+BOOL RectInRegion( HRGN hrgn, LPRECT rect )
+{
+    XImage * image;
+    RGNOBJ * obj;
+    RECT intersect;
+    int x, y;
+    
+    if (!(obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return FALSE;
+    if (!IntersectRect( &intersect, &obj->region.box, rect )) return FALSE;
+    
+    image = XGetImage( XT_display, obj->region.pixmap,
+		       intersect.left - obj->region.box.left,
+		       intersect.top - obj->region.box.top,
+		       intersect.right - intersect.left,
+		       intersect.bottom - intersect.top,
+		       AllPlanes, ZPixmap );
+    if (!image) return FALSE;
+    for (y = 0; y < image->height; y++)
+	for (x = 0; x < image->width; x++)
+	    if (XGetPixel( image, x, y ) != 0)
+	    {
+		XDestroyImage( image );
+		return TRUE;
+	    }
+    
+    XDestroyImage( image );
+    return FALSE;
+}
+
+
+/***********************************************************************
+ *           EqualRgn    (GDI.72)
+ */
+BOOL EqualRgn( HRGN rgn1, HRGN rgn2 )
+{
+    RGNOBJ *obj1, *obj2;
+    XImage *image1, *image2;
+    int width, height, x, y;
+
+      /* Compare bounding boxes */
+
+    if (!(obj1 = (RGNOBJ *) GDI_GetObjPtr( rgn1, REGION_MAGIC ))) return FALSE;
+    if (!(obj2 = (RGNOBJ *) GDI_GetObjPtr( rgn2, REGION_MAGIC ))) return FALSE;
+    if (obj1->region.type == NULLREGION)
+	return (obj2->region.type == NULLREGION);
+    else if (obj2->region.type == NULLREGION) return FALSE;
+    if (!EqualRect( &obj1->region.box, &obj2->region.box )) return FALSE;
+
+      /* Get pixmap contents */
+
+    width  = obj1->region.box.right - obj1->region.box.left;
+    height = obj1->region.box.bottom - obj1->region.box.top;
+    image1 = XGetImage( XT_display, obj1->region.pixmap,
+		        0, 0, width, height, AllPlanes, ZPixmap );
+    if (!image1) return FALSE;
+    image2 = XGetImage( XT_display, obj2->region.pixmap,
+		        0, 0, width, height, AllPlanes, ZPixmap );
+    if (!image2)
+    {
+	XDestroyImage( image1 );
+	return FALSE;
+    }
+    
+      /* Compare pixmaps */
+    for (y = 0; y < height; y++)
+	for (x = 0; x < width; x++)
+	    if (XGetPixel( image1, x, y ) != XGetPixel( image2, x, y))
+	    {
+		XDestroyImage( image1 );
+		XDestroyImage( image2 );
+		return FALSE;
+	    }
+    
+    XDestroyImage( image1 );
+    XDestroyImage( image2 );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           REGION_CopyIntersection
+ *
+ * Copy to dest->pixmap the area of src->pixmap delimited by
+ * the intersection of dest and src regions, using the current GC function.
+ */
+void REGION_CopyIntersection( REGION * dest, REGION * src )
+{
+    RECT inter;
+    if (!IntersectRect( &inter, &dest->box, &src->box )) return;
+    XCopyArea( XT_display, src->pixmap, dest->pixmap, regionGC,
+	       inter.left - src->box.left, inter.top - src->box.top,
+	       inter.right - inter.left, inter.bottom - inter.top,
+	       inter.left - dest->box.left, inter.top - dest->box.top );
+}
+
+
+/***********************************************************************
+ *           CombineRgn    (GDI.451)
+ */
+int CombineRgn( HRGN hDest, HRGN hSrc1, HRGN hSrc2, short mode )
+{
+    RGNOBJ *destObj, *src1Obj, *src2Obj;
+    REGION * region;
+    int width, height;
+    BOOL res;
+    
+#ifdef DEBUG_REGION
+    printf( "CombineRgn: %d %d %d %d\n", hDest, hSrc1, hSrc2, mode );
+#endif
+    
+    if (!(destObj = (RGNOBJ *) GDI_GetObjPtr( hDest, REGION_MAGIC )))
+	return ERROR;
+    if (!(src1Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc1, REGION_MAGIC )))
+	return ERROR;
+    if (mode != RGN_COPY)
+	if (!(src2Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc2, REGION_MAGIC )))
+	    return ERROR;
+    region = &destObj->region;
+
+    switch(mode)
+    {
+      case RGN_AND:
+	res = IntersectRect( &region->box, &src1Obj->region.box,
+			     &src2Obj->region.box );
+	break;
+
+      case RGN_OR:
+      case RGN_XOR:
+	res = UnionRect( &region->box, &src1Obj->region.box,
+			 &src2Obj->region.box );
+	break;
+
+      case RGN_DIFF:
+	res = SubtractRect( &region->box, &src1Obj->region.box,
+			    &src2Obj->region.box );
+	break;
+
+      case RGN_COPY:
+	region->box  = src1Obj->region.box;
+	region->type = src1Obj->region.type;
+	res = (region->type != NULLREGION);
+	break;
+
+      default:
+	return ERROR;
+    }
+
+    if (region->pixmap) XFreePixmap( XT_display, region->pixmap );    
+    if (!res)
+    {
+	region->type   = NULLREGION;
+	region->pixmap = 0;
+	return NULLREGION;
+    }
+    
+    width  = region->box.right - region->box.left;
+    height = region->box.bottom - region->box.top;
+    region->pixmap = XCreatePixmap( XT_display, DefaultRootWindow(XT_display),
+				    width, height, 1 );
+
+    switch(mode)
+    {
+      case RGN_AND:
+	  XSetFunction( XT_display, regionGC, GXcopy );
+	  REGION_CopyIntersection( region, &src1Obj->region );
+	  XSetFunction( XT_display, regionGC, GXand );
+	  REGION_CopyIntersection( region, &src2Obj->region );
+	  return COMPLEXREGION;
+
+      case RGN_OR:
+      case RGN_XOR:
+	  XSetFunction( XT_display, regionGC, GXclear );
+	  XFillRectangle( XT_display, region->pixmap, regionGC,
+			  0, 0, width, height );
+	  XSetFunction( XT_display, regionGC, (mode == RGN_OR) ? GXor : GXxor);
+	  REGION_CopyIntersection( region, &src1Obj->region );
+	  REGION_CopyIntersection( region, &src2Obj->region );
+	  return COMPLEXREGION;
+	  
+      case RGN_DIFF:
+	  XSetFunction( XT_display, regionGC, GXclear );
+	  XFillRectangle( XT_display, region->pixmap, regionGC,
+			  0, 0, width, height );
+	  XSetFunction( XT_display, regionGC, GXcopy );
+	  REGION_CopyIntersection( region, &src1Obj->region );
+	  XSetFunction( XT_display, regionGC, GXandInverted );
+	  REGION_CopyIntersection( region, &src2Obj->region );
+	  return COMPLEXREGION;
+	  
+      case RGN_COPY:
+	  XSetFunction( XT_display, regionGC, GXcopy );
+	  XCopyArea( XT_display, src1Obj->region.pixmap, region->pixmap,
+		     regionGC, 0, 0, width, height, 0, 0 );
+	  return region->type;
+    }
+    return ERROR;
+}
diff --git a/objects/text.c b/objects/text.c
new file mode 100644
index 0000000..43b095a
--- /dev/null
+++ b/objects/text.c
@@ -0,0 +1,168 @@
+/*
+ * text functions
+ *
+ * Copyright 1993 Alexandre Julliard
+ */
+
+static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
+
+#include <X11/Intrinsic.h>
+#include <X11/StringDefs.h>
+#include <X11/Core.h>
+#include <X11/Shell.h>
+#include <X11/Xatom.h>
+
+#include "message.h"
+#include "callback.h"
+#include "win.h"
+#include "gdi.h"
+
+
+/***********************************************************************
+ *           DrawText    (USER.85)
+ */
+int DrawText( HDC hdc, LPSTR str, int count, LPRECT rect, WORD flags )
+{
+    int x = rect->left, y = rect->top;
+    if (flags & DT_CENTER) x = (rect->left + rect->right) / 2;
+    if (flags & DT_VCENTER) y = (rect->top + rect->bottom) / 2;
+    if (count == -1) count = strlen(str);
+
+    if (!TextOut( hdc, x, y, str, count )) return 0;
+    return 1;
+}
+
+
+/***********************************************************************
+ *           TextOut    (GDI.33)
+ */
+BOOL TextOut( HDC hdc, short x, short y, LPSTR str, short count )
+{
+    int dir, ascent, descent, i;
+    XCharStruct info;
+    XFontStruct *font;
+
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc) return FALSE;
+    if (!DC_SetupGCForText( dc )) return TRUE;
+    font = dc->u.x.font.fstruct;
+
+    if (dc->w.textAlign & TA_UPDATECP)
+    {
+	x = dc->w.CursPosX;
+	y = dc->w.CursPosY;
+    }
+#ifdef DEBUG_TEXT
+    printf( "TextOut: %d,%d '%s'\n", x, y, str );
+#endif
+    x = XLPTODP( dc, x );
+    y = YLPTODP( dc, y );
+
+    XTextExtents( font, str, count, &dir, &ascent, &descent, &info );
+    info.width += count*dc->w.charExtra + dc->w.breakExtra*dc->w.breakCount;
+
+      /* Compute starting position */
+
+    switch( dc->w.textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER) )
+    {
+      case TA_LEFT:
+ 	  if (dc->w.textAlign & TA_UPDATECP)
+	      dc->w.CursPosX = XDPTOLP( dc, x + info.width );
+	  break;
+      case TA_RIGHT:
+	  x -= info.width;
+	  if (dc->w.textAlign & TA_UPDATECP) dc->w.CursPosX = XDPTOLP( dc, x );
+	  break;
+      case TA_CENTER:
+	  x -= info.width / 2;
+	  break;
+    }
+    switch( dc->w.textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE) )
+    {
+      case TA_TOP:
+	  y += font->ascent;
+	  break;
+      case TA_BOTTOM:
+	  y -= font->descent;
+	  break;
+      case TA_BASELINE:
+	  break;
+    }
+
+      /* Draw text */
+
+    if (!dc->w.charExtra && !dc->w.breakExtra)
+    {
+	if (dc->w.backgroundMode == TRANSPARENT)
+	    XDrawString( XT_display, dc->u.x.drawable, dc->u.x.gc, 
+			 x, y, str, count );
+	else
+	    XDrawImageString( XT_display, dc->u.x.drawable, dc->u.x.gc,
+			      x, y, str, count );
+    }
+    else
+    {
+	char * p = str;
+	int xchar = x;
+	for (i = 0; i < count; i++, p++)
+	{
+	    XCharStruct * charStr;
+	    unsigned char ch = *p;
+	    int extraWidth;
+	    
+	    if ((ch < font->min_char_or_byte2)||(ch > font->max_char_or_byte2))
+		ch = font->default_char;
+	    if (!font->per_char) charStr = &font->min_bounds;
+	    else charStr = font->per_char + ch - font->min_char_or_byte2;
+
+	    extraWidth = dc->w.charExtra;
+	    if (ch == dc->u.x.font.metrics.tmBreakChar)
+		extraWidth += dc->w.breakExtra;
+
+	    if (dc->w.backgroundMode == TRANSPARENT)
+		XDrawString( XT_display, dc->u.x.drawable, dc->u.x.gc,
+			     xchar, y, p, 1 );
+	    else
+	    {
+		XDrawImageString( XT_display, dc->u.x.drawable, dc->u.x.gc,
+				  xchar, y, p, 1 );
+		XSetForeground( XT_display, dc->u.x.gc, dc->w.backgroundPixel);
+		XFillRectangle( XT_display, dc->u.x.drawable, dc->u.x.gc,
+			        xchar + charStr->width, y - font->ascent,
+			        extraWidth, font->ascent + font->descent );
+		XSetForeground( XT_display, dc->u.x.gc, dc->w.textPixel );
+	    }
+	    xchar += charStr->width + extraWidth;
+	}
+    }
+
+      /* Draw underline and strike-out if needed */
+
+    if (dc->u.x.font.metrics.tmUnderlined)
+    {
+	long linePos, lineWidth;       
+	if (!XGetFontProperty( font, XA_UNDERLINE_POSITION, &linePos ))
+	    linePos = font->descent-1;
+	if (!XGetFontProperty( font, XA_UNDERLINE_THICKNESS, &lineWidth ))
+	    lineWidth = 0;
+	else if (lineWidth == 1) lineWidth = 0;
+	XSetLineAttributes( XT_display, dc->u.x.gc, lineWidth,
+			    LineSolid, CapRound, JoinBevel ); 
+	XDrawLine( XT_display, dc->u.x.drawable, dc->u.x.gc,
+		   x, y + linePos, x + info.width, y + linePos );
+    }
+    if (dc->u.x.font.metrics.tmStruckOut)
+    {
+	long lineAscent, lineDescent;
+	if (!XGetFontProperty( font, XA_STRIKEOUT_ASCENT, &lineAscent ))
+	    lineAscent = font->ascent / 3;
+	if (!XGetFontProperty( font, XA_STRIKEOUT_DESCENT, &lineDescent ))
+	    lineDescent = -lineAscent;
+	XSetLineAttributes( XT_display, dc->u.x.gc, lineAscent + lineDescent,
+			    LineSolid, CapRound, JoinBevel ); 
+	XDrawLine( XT_display, dc->u.x.drawable, dc->u.x.gc,
+		   x, y - lineAscent, x + info.width, y - lineAscent );
+    }
+    
+    return TRUE;
+}