/*
 * bltTile.c --
 *
 *	This module manages images for tiled backgrounds for the BLT toolkit.
 *
 * Copyright 1995-1998 Lucent Technologies, Inc.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby
 * granted, provided that the above copyright notice appear in all
 * copies and that both that the copyright notice and warranty
 * disclaimer appear in supporting documentation, and that the names
 * of Lucent Technologies any of their entities not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 *
 * Lucent Technologies disclaims all warranties with regard to this
 * software, including all implied warranties of merchantability and
 * fitness.  In no event shall Lucent Technologies be liable for any
 * special, indirect or consequential damages or any damages
 * whatsoever resulting from loss of use, data or profits, whether in
 * an action of contract, negligence or other tortuous action, arising
 * out of or in connection with the use or performance of this
 * software.
 */

#include "bltInt.h"
#include "bltChain.h"
#include "bltHash.h"
#include "bltImage.h"
#include <X11/Xutil.h>

#include "bltTile.h"

#define TILE_THREAD_KEY	"BLT Tile Data"
#define TILE_MAGIC ((unsigned int) 0x46170277)

typedef struct {
    Blt_HashTable tileTable;	/* Hash table of tile structures keyed by 
				 * the name of the image. */
    Tcl_Interp *interp;
} TileInterpData;

typedef struct {
    char *name;			/* Name of image used to generate the pixmap.*/
    Display *display;		/* Display where pixmap was created. */
    int flags;			/* See definitions below. */
    Tcl_Interp *interp;
    Blt_HashEntry *hashPtr;	/* Pointer to hash table location */
    Blt_HashTable *tablePtr;

    Pixmap pixmap;		/* Pixmap generated from image. */
    Pixmap mask;		/* Monochrome pixmap used as
				 * transparency mask. */
    GC gc;			/* GC */
    Tk_Image tkImage;		/* Tk image token. */
    Blt_Chain *clients;		/* Chain of clients sharing this tile. */
    int width, height;		
} Tile;

#define NOTIFY_PENDING	1	/* If set, indicates that the image
				 * associated with the tile has been
				 * updated or deleted.  The tile pixmap
				 * will be changed and the clients of the
				 * tile will be notified (if they supplied
				 * a TileChangedProc routine. */

typedef struct Blt_TileClientStruct {
    unsigned int magic;
    Tk_Window tkwin;		/* Client window. */
    int xOrigin, yOrigin;	/* Tiling origin in relation to the
				 * client window. */
    Blt_TileChangedProc *notifyProc; /* If non-NULL, routine to
				 * call to when tile image changes. */
    ClientData clientData;	/* Data to pass to when calling the above
				 * routine. */
    Tile *tilePtr;		/* Pointer to actual tile information */
    Blt_ChainLink *linkPtr;	/* Pointer to client entry in the server's
				 * client list.  Used to delete the client */
} TileClient;

typedef struct {
    Display *display;
    Tk_Uid nameId;
    int depth;
} TileKey;
    
static TileInterpData *GetTileInterpData _ANSI_ARGS_((Tcl_Interp *interp));

static Tcl_IdleProc UpdateTile;
static Tk_ImageChangedProc ImageChangedProc;
static Tcl_InterpDeleteProc TileInterpDeleteProc;

static void DestroyClient _ANSI_ARGS_((TileClient *clientPtr));
static void DestroyTile _ANSI_ARGS_((Tile *tilePtr));


/*
 *----------------------------------------------------------------------
 *
 * RedrawTile --
 *
 *	Generates a pixmap and draws the tile image into it.  Also
 *	a tranparency mask is possibly generated from the image.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */
static void
RedrawTile(tkwin, tilePtr)
    Tk_Window tkwin;
    Tile *tilePtr;
{
    GC newGC;
    Tk_PhotoHandle photo;
    XGCValues gcValues;
    int width, height;
    unsigned int gcMask;
    
    Tk_SizeOfImage(tilePtr->tkImage, &width, &height);

    Tk_MakeWindowExist(tkwin);
    if ((width != tilePtr->width) || (height != tilePtr->height)) {
	Pixmap pixmap;

	/*
	 * Create the new pixmap *before* destroying the old one.  I don't
	 * why this happens, but if you delete the old pixmap first, the
	 * old pixmap sometimes gets used in the client's GCs.  I suspect
	 * it has something to do with the way Tk reallocates X resource
	 * identifiers.  
	 */
	pixmap = Tk_GetPixmap(Tk_Display(tkwin), Tk_WindowId(tkwin), width, 
			      height, Tk_Depth(tkwin));
	if (tilePtr->pixmap != None) {
	    Tk_FreePixmap(Tk_Display(tkwin), tilePtr->pixmap);
	}
	tilePtr->pixmap = pixmap;
    }
    Tk_RedrawImage(tilePtr->tkImage, 0, 0, width, height, tilePtr->pixmap, 
	0, 0);
    
    gcMask = (GCTile | GCFillStyle);
    gcValues.fill_style = FillTiled;
    gcValues.tile = tilePtr->pixmap;
    newGC = Tk_GetGC(tkwin, gcMask, &gcValues);
    if (tilePtr->gc != NULL) {
	Tk_FreeGC(Tk_Display(tkwin), tilePtr->gc);
    }
    tilePtr->gc = newGC;
    tilePtr->width = width;
    tilePtr->height = height;

    if (tilePtr->mask != None) {
#ifdef WIN32
	Tk_FreePixmap(Tk_Display(tkwin), tilePtr->mask);
#else 
	XFreePixmap(Tk_Display(tkwin), tilePtr->mask);
#endif /* WIN32 */
	tilePtr->mask = None;
    }
    photo = Blt_FindPhoto(tilePtr->interp, 
			  Blt_NameOfImage(tilePtr->tkImage));
    if (photo != NULL) {
	Tk_PhotoImageBlock src;

	Tk_PhotoGetImage(photo, &src);
	if ((src.offset[3] < src.pixelSize) && (src.offset[3] >= 0)) {
	    tilePtr->mask = Blt_PhotoImageMask(tkwin, src);
	}
    }
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateTile --
 *
 *	It would be better if Tk checked for NULL proc pointers.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */
static void
UpdateTile(clientData)
    ClientData clientData;
{
    Tile *tilePtr = (Tile *)clientData;
    TileClient *clientPtr;
    Blt_ChainLink *linkPtr;

    tilePtr->flags &= ~NOTIFY_PENDING;
    if (Tk_ImageIsDeleted(tilePtr->tkImage)) {
	if (tilePtr->pixmap != None) {
	    Tk_FreePixmap(tilePtr->display, tilePtr->pixmap);
	}
	tilePtr->pixmap = None;
    } else {
	/* Pick any client window to generate the new pixmap. */
	linkPtr = Blt_ChainFirstLink(tilePtr->clients);
	clientPtr = Blt_ChainGetValue(linkPtr);
	RedrawTile(clientPtr->tkwin, tilePtr);
    }

    /* Notify each of the tile's clients that the pixmap has changed. */

    for (linkPtr = Blt_ChainFirstLink(tilePtr->clients); linkPtr != NULL;
	linkPtr = Blt_ChainNextLink(linkPtr)) {
	clientPtr = Blt_ChainGetValue(linkPtr);
	if (clientPtr->notifyProc != NULL) {
	    (*clientPtr->notifyProc) (clientPtr->clientData, clientPtr);
	}
    }
}

/*
 *----------------------------------------------------------------------
 *
 * ImageChangedProc
 *
 *	The Tk image has changed or been deleted, redraw the pixmap
 *	tile.
 *
 *	Note:	As of Tk 4.2 (rechecked in 8.3), if you redraw Tk 
 *		images from a Tk_ImageChangedProc you'll get a 
 *		coredump.  As a workaround, we have to simulate 
 *		how the Tk widgets use images and redraw within 
 *		an idle event.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */
/* ARGSUSED */
static void
ImageChangedProc(clientData, x, y, width, height, imageWidth, imageHeight)
    ClientData clientData;
    int x, y, width, height;	/* Not used. */
    int imageWidth, imageHeight; /* Not used. */
{
    Tile *tilePtr = (Tile *) clientData;

    if (!(tilePtr->flags & NOTIFY_PENDING)) {
	Tcl_DoWhenIdle(UpdateTile, tilePtr);
	tilePtr->flags |= NOTIFY_PENDING;
    }
}

/*
 *----------------------------------------------------------------------
 *
 * DestroyTile --
 *
 *	Deletes the core tile structure, including the pixmap
 *	representing the tile.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */
static void
DestroyTile(Tile *tilePtr)
{
    Blt_ChainLink *linkPtr;
    TileClient *clientPtr;

    if (tilePtr->flags & NOTIFY_PENDING) {
	Tcl_CancelIdleCall(UpdateTile, tilePtr);
    }
    for (linkPtr = Blt_ChainFirstLink(tilePtr->clients); linkPtr != NULL;
	linkPtr = Blt_ChainNextLink(linkPtr)) {
	clientPtr = Blt_ChainGetValue(linkPtr);
	Blt_Free(clientPtr);
    }
    Blt_ChainDestroy(tilePtr->clients);

    if (tilePtr->hashPtr != NULL) {
	Blt_DeleteHashEntry(tilePtr->tablePtr, tilePtr->hashPtr);
    }
    if (tilePtr->pixmap != None) {
	Tk_FreePixmap(tilePtr->display, tilePtr->pixmap);
    }
    Tk_FreeImage(tilePtr->tkImage);

    if (tilePtr->gc != NULL) {
	Tk_FreeGC(tilePtr->display, tilePtr->gc);
    }
    if (tilePtr->name != NULL) {
	Blt_Free(tilePtr->name);
    }
    Blt_Free(tilePtr);
}

/*
 *----------------------------------------------------------------------
 *
 * CreateTile --
 *
 *	Creates a tile server.  A tile server manages a single image,
 *	possibly shared by several clients.  Clients will be updated
 *	(if requested) by the server if the image changes, so they
 *	know to redraw themselves.  For X11 the image is drawn into a
 *	pixmap that is used in a new GC as its tile.  For Windows we
 *	have to do the tiling ourselves by redrawing the image across
 *	the drawing area (see Blt_TileRectangle and Blt_TilePolygon).
 *
 * Results:
 *	Returns a pointer to the new tile server.  If the image name
 *	does not represent a Tk image, NULL is returned.
 *
 *---------------------------------------------------------------------- 
 */
static Tile *
CreateTile(
    Tcl_Interp *interp,
    Tk_Window tkwin,
    char *imageName)
{
    Tile *tilePtr;
    Tk_Image tkImage;

    tilePtr = Blt_Calloc(1, sizeof(Tile));
    assert(tilePtr);
    /*
     * Get the image. Funnel all change notifications to a single routine.
     */
    tkImage = Tk_GetImage(interp, tkwin, imageName, ImageChangedProc,
	tilePtr);
    if (tkImage == NULL) {
	Blt_Free(tilePtr);
	return NULL;
    }

    /*
     * Initialize the tile server.
     */
    tilePtr->display = Tk_Display(tkwin);
    tilePtr->interp = interp;
    tilePtr->name = Blt_Strdup(imageName);
    tilePtr->clients = Blt_ChainCreate();
    tilePtr->tkImage = tkImage;
    RedrawTile(tkwin, tilePtr);
    return tilePtr;
}

/*
 *----------------------------------------------------------------------
 *
 * DestroyClient --
 *
 *	Removes the client from the servers's list of clients and
 *	memory used by the client token is released.  When the last
 *	client is deleted, the server is also removed.
 *
 * Results:
 *	None.
 *
 *---------------------------------------------------------------------- 
 */
static void
DestroyClient(TileClient *clientPtr)
{
    Tile *tilePtr;
    tilePtr = clientPtr->tilePtr;

    /* Remove the client from the server's list */
    if (clientPtr->linkPtr != NULL) {
	Blt_ChainDeleteLink(tilePtr->clients, clientPtr->linkPtr);
    }
    if (Blt_ChainGetLength(tilePtr->clients) == 0) {
	/*
	 * If there are no more clients of the tile, then remove the
	 * pixmap, image, and the server record.
	 */
	DestroyTile(tilePtr);
    }
    Blt_Free(clientPtr);
}

/*
 *----------------------------------------------------------------------
 *
 * CreateClient --
 *
 *	Returns a token to a tile (possibly shared by many clients).
 *	A client uses the token to query or display the tile.  Clients
 *	request tiles by their image names.  Each tile is known by its
 *	display, screen depth, and image name.  The tile server tracks
 *	what clients are using the tile and notifies them (via a
 *	callback) whenever the tile changes. If no server exists
 *	already, one is created on-the-fly.
 *
 * Results:
 *	A pointer to the newly created client (i.e. tile).
 *
 *---------------------------------------------------------------------- 
 */
static TileClient *
CreateClient(
    Tcl_Interp *interp,
    Tk_Window tkwin,
    char *name)
{
    TileClient *clientPtr;
    Tile *tilePtr;
    TileInterpData *dataPtr;
    Blt_HashEntry *hPtr;
    int isNew;
    TileKey key;

    dataPtr = GetTileInterpData(interp);

    key.nameId = Tk_GetUid(name);
    key.display = Tk_Display(tkwin);
    key.depth = Tk_Depth(tkwin);
    hPtr = Blt_CreateHashEntry(&dataPtr->tileTable, (char *)&key, &isNew);
    if (isNew) {
	tilePtr = CreateTile(interp, tkwin, name);
	if (tilePtr == NULL) {
	    Blt_DeleteHashEntry(&(dataPtr->tileTable), hPtr);
	    return NULL;
	}
	tilePtr->hashPtr = hPtr;
	tilePtr->tablePtr = &(dataPtr->tileTable);
	Blt_SetHashValue(hPtr, tilePtr);
    } else {
	tilePtr = Blt_GetHashValue(hPtr);
    }
    clientPtr = Blt_Calloc(1, sizeof(TileClient));
    assert(clientPtr);

    /* Initialize client information. */
    clientPtr->magic = TILE_MAGIC;
    clientPtr->tkwin = tkwin;
    clientPtr->linkPtr = Blt_ChainAppend(tilePtr->clients, clientPtr);
    clientPtr->tilePtr = tilePtr;
    return clientPtr;
}

/*
 * -----------------------------------------------------------------------
 *
 * TileInterpDeleteProc --
 *
 *	This is called when the interpreter is deleted. All the tiles
 *	are specific to that interpreter are destroyed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Destroys the tile table.
 *
 * ------------------------------------------------------------------------
 */
/* ARGSUSED */
static void
TileInterpDeleteProc(
    ClientData clientData,	/* Thread-specific data. */
    Tcl_Interp *interp)
{
    TileInterpData *dataPtr = clientData;
    Blt_HashEntry *hPtr;
    Blt_HashSearch cursor;
    Tile *tilePtr;
    
    for (hPtr = Blt_FirstHashEntry(&(dataPtr->tileTable), &cursor);
	 hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
	tilePtr = Blt_GetHashValue(hPtr);
	tilePtr->hashPtr = NULL;
	DestroyTile(tilePtr);
    }
    Blt_DeleteHashTable(&(dataPtr->tileTable));
    Tcl_DeleteAssocData(interp, TILE_THREAD_KEY);
    Blt_Free(dataPtr);
}

static TileInterpData *
GetTileInterpData(interp)
     Tcl_Interp *interp;
{
    TileInterpData *dataPtr;
    Tcl_InterpDeleteProc *proc;

    dataPtr = (TileInterpData *)
	Tcl_GetAssocData(interp, TILE_THREAD_KEY, &proc);
    if (dataPtr == NULL) {
	dataPtr = Blt_Malloc(sizeof(TileInterpData));
	assert(dataPtr);
	dataPtr->interp = interp;
	Tcl_SetAssocData(interp, TILE_THREAD_KEY, TileInterpDeleteProc, 
		dataPtr);
	Blt_InitHashTable(&(dataPtr->tileTable), sizeof(TileKey)/sizeof(int));
    }
    return dataPtr;
}


/* Public API for tiles. */

/*
 *----------------------------------------------------------------------
 *
 * Blt_GetTile
 *
 *	Convert the named image into a tile.
 *
 * Results:
 *	If the image is valid, a new tile is returned.  If the name
 *	does not represent a proper image, an error message is left in
 *	interp->result.
 *
 *----------------------------------------------------------------------
 */
/*LINTLIBRARY*/
int
Blt_GetTile(
    Tcl_Interp *interp,		/* Interpreter to report results back to */
    Tk_Window tkwin,		/* Window on the same display as tile */
    char *imageName,		/* Name of image */
    Blt_Tile *tokenPtr)		/* (out) Returns the allocated tile token. */
{
    TileClient *clientPtr;

    clientPtr = CreateClient(interp, tkwin, imageName);
    if (clientPtr == NULL) {
	return TCL_ERROR;
    } 
    *tokenPtr = clientPtr;
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_FreeTile
 *
 *	Release the resources associated with the tile.
 *
 * Results:
 *	None.
 *
 * Side Effects:
 *	Memory and X resources are freed.  Bookkeeping information
 *	about the tile (i.e. width, height, and name) is discarded.
 *
 *----------------------------------------------------------------------
 */
/*LINTLIBRARY*/
void
Blt_FreeTile(TileClient *clientPtr) /* Tile to be deleted */
{
    if ((clientPtr == NULL) || (clientPtr->magic != TILE_MAGIC)) {
	return;			/* No tile */
    }
    DestroyClient(clientPtr);
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_NameOfTile
 *
 *	Returns the name of the image from which the tile was
 *	generated.
 *
 * Results:
 *	The name of the image is returned.  The name is not unique.
 *	Many tiles may use the same image.
 *
 *----------------------------------------------------------------------
 */
/*LINTLIBRARY*/
char *
Blt_NameOfTile(TileClient *clientPtr) /* Tile to query */
{
    if (clientPtr == NULL) {
	return "";
    }
    if (clientPtr->magic != TILE_MAGIC) {
	return "not a tile";
    }
    return clientPtr->tilePtr->name;
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_PixmapOfTile
 *
 *	Returns the pixmap of the tile.
 *
 * Results:
 *	The X pixmap used as the tile is returned.
 *
 *----------------------------------------------------------------------
 */
/*LINTLIBRARY*/
Pixmap
Blt_PixmapOfTile(TileClient *clientPtr) /* Tile to query */
{
    if ((clientPtr == NULL) || (clientPtr->magic != TILE_MAGIC)) {
	return None;
    }
    return clientPtr->tilePtr->pixmap;
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_SizeOfTile
 *
 *	Returns the width and height of the tile.
 *
 * Results:
 *	The width and height of the tile are returned.
 *
 *----------------------------------------------------------------------
 */
/*LINTLIBRARY*/
void
Blt_SizeOfTile(
    TileClient *clientPtr,	/* Tile to query */
    int *widthPtr, 
    int *heightPtr)		/* Returned dimensions of the tile (out) */
{
    if ((clientPtr == NULL) || (clientPtr->magic != TILE_MAGIC)) {
	*widthPtr = *heightPtr = 0;
	return;			/* No tile given. */
    }
    *widthPtr = clientPtr->tilePtr->width;
    *heightPtr = clientPtr->tilePtr->height;
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_SetTileChangedProc
 *
 *	Sets the routine to called when an image changes.  
 *
 * Results:
 *	None.
 *
 * Side Effects:
 *	The designated routine will be called the next time the
 *	image associated with the tile changes.
 *
 *----------------------------------------------------------------------
 */
/*LINTLIBRARY*/
void
Blt_SetTileChangedProc(
    TileClient *clientPtr,		/* Tile to query */
    Blt_TileChangedProc *notifyProc,
    ClientData clientData)
{
    if ((clientPtr != NULL) && (clientPtr->magic == TILE_MAGIC)) {
	clientPtr->notifyProc = notifyProc;
	clientPtr->clientData = clientData;
    }
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_SetTileOrigin --
 *
 *	Set the pattern origin of the tile to a common point (i.e. the
 *	origin (0,0) of the top level window) so that tiles from two
 *	different widgets will match up.  This done by setting the
 *	GCTileStipOrigin field is set to the translated origin of the
 *	toplevel window in the hierarchy.
 *
 * Results:
 *	None.
 *
 * Side Effects:
 *	The GCTileStipOrigin is reset in the GC.  This will cause the
 *	tile origin to change when the GC is used for drawing.
 *
 *----------------------------------------------------------------------
 */
/*ARGSUSED*/
void
Blt_SetTileOrigin(
    Tk_Window tkwin,
    TileClient *clientPtr,
    int x, int y)
{
    while (!Tk_IsTopLevel(tkwin)) {
	x += Tk_X(tkwin) + Tk_Changes(tkwin)->border_width;
	y += Tk_Y(tkwin) + Tk_Changes(tkwin)->border_width;
	tkwin = Tk_Parent(tkwin);
    }
    XSetTSOrigin(Tk_Display(tkwin), clientPtr->tilePtr->gc, -x, -y);
    clientPtr->xOrigin = -x;
    clientPtr->yOrigin = -y;
}

void
Blt_SetTSOrigin(
    Tk_Window tkwin,
    TileClient *clientPtr,
    int x, int y)
{
    XSetTSOrigin(Tk_Display(tkwin), clientPtr->tilePtr->gc, x, y);
    clientPtr->xOrigin = x;
    clientPtr->yOrigin = y;
}

#ifdef WIN32
static int tkpWinRopModes[] =
{
    R2_BLACK,			/* GXclear */
    R2_MASKPEN,			/* GXand */
    R2_MASKPENNOT,		/* GXandReverse */
    R2_COPYPEN,			/* GXcopy */
    R2_MASKNOTPEN,		/* GXandInverted */
    R2_NOT,			/* GXnoop */
    R2_XORPEN,			/* GXxor */
    R2_MERGEPEN,		/* GXor */
    R2_NOTMERGEPEN,		/* GXnor */
    R2_NOTXORPEN,		/* GXequiv */
    R2_NOT,			/* GXinvert */
    R2_MERGEPENNOT,		/* GXorReverse */
    R2_NOTCOPYPEN,		/* GXcopyInverted */
    R2_MERGENOTPEN,		/* GXorInverted */
    R2_NOTMASKPEN,		/* GXnand */
    R2_WHITE			/* GXset */
};
#define MASKPAT		0x00E20746 /* dest = (src & pat) | (!src & dst) */
#define COPYFG		0x00CA0749 /* dest = (pat & src) | (!pat & dst) */
#define COPYBG		0x00AC0744 /* dest = (!pat & src) | (pat & dst) */

static void
TileRegion(
    HDC srcDC,			/* Source device context. */
    HDC destDC,			/* Destination device context. */
    HDC maskDC,			/* If non-NULL, device context of the
				 * mask tile mask. */
    TileClient *clientPtr,
    int x, int y, 
    int width, int height)
{
    Tile *tilePtr = clientPtr->tilePtr;
    int destX, destY;
    int destWidth, destHeight;
    int srcX, srcY;
    int startX, startY;		/* Starting upper left corner of region. */
    int delta;
    int left, top, right, bottom;

    startX = x;
    if (x < clientPtr->xOrigin) {
	delta = (clientPtr->xOrigin - x) % tilePtr->width;
	if (delta > 0) {
	    startX -= (tilePtr->width - delta);
	}
    } else if (x > clientPtr->xOrigin) {
	delta = (x - clientPtr->xOrigin) % tilePtr->width;
	if (delta > 0) {
	    startX -= delta;
	}
    }
    startY = y;
    if (y < clientPtr->yOrigin) {
	delta = (clientPtr->yOrigin - y) % tilePtr->height;
	if (delta > 0) {
	    startY -= (tilePtr->height - delta);
	}
    } else if (y >= clientPtr->yOrigin) {
	delta = (y - clientPtr->yOrigin) % tilePtr->height;
	if (delta > 0) {
	    startY -= delta;
	}
    }
#ifdef notdef
    PurifyPrintf("tile is (%d,%d,%d,%d)\n", 
		 clientPtr->xOrigin, clientPtr->yOrigin, 
		 tilePtr->width, tilePtr->height);
    PurifyPrintf("region is (%d,%d,%d,%d)\n", x, y, width, height);
    PurifyPrintf("starting at %d,%d\n", startX, startY);
#endif
    left = x;
    right = x + width;
    top = y;
    bottom = y + height;
    for (y = startY; y < bottom; y += tilePtr->height) {
	srcY = 0;
	destY = y;
	destHeight = tilePtr->height;
	if (y < top) {
	    srcY = (top - y);
	    destHeight = tilePtr->height - srcY;
	    destY = top;
	} 
	if ((destY + destHeight) > bottom) {
	    destHeight = (bottom - destY);
	}
	for (x = startX; x < right; x += tilePtr->width) {
	    srcX = 0;
	    destX = x;
	    destWidth = tilePtr->width;
	    if (x < left) {
		srcX = (left - x);
		destWidth = tilePtr->width - srcX;
		destX = left;
	    } 
	    if ((destX + destWidth) > right) {
		destWidth = (right - destX);
	    }
#ifdef notdef
	    PurifyPrintf("drawing pattern (%d,%d,%d,%d) at %d,%d\n",
		 srcX , srcY, destWidth, destHeight, destX, destY);
#endif
	    if (tilePtr->mask != None) { /* With transparency. */
#ifdef notdef
		HDC maskDC;
		TkWinDCState maskState;

		maskDC = TkWinGetDrawableDC(tilePtr->display, 
			tilePtr->mask, &maskState);
		SetBkColor(destDC, RGB(255, 255, 255));      
		SetTextColor(destDC, RGB(0, 0, 0));
#endif
		BitBlt(destDC, destX, destY, destWidth, destHeight, maskDC, 
		       0, 0, SRCAND);
		BitBlt(destDC, destX, destY, destWidth, destHeight, srcDC, 
		       srcX, srcY, SRCPAINT);
#ifdef notdef
		TkWinReleaseDrawableDC(tilePtr->mask, maskDC, &maskState);
#endif
	    } else {		/* Opaque tile. */
	        BitBlt(destDC, destX, destY, destWidth, destHeight, 
		       srcDC, srcX, srcY, SRCCOPY);
	    }
	}
    }
}

void
Blt_TilePolygon(
    Tk_Window tkwin,
    Drawable drawable,
    TileClient *clientPtr,
    XPoint pointArr[],
    int nPoints)
{
    HBITMAP oldBitmap;
    HDC hDC, memDC;
    HRGN hRgn;
    POINT *p, *winPts;
    Region2D bbox;
    Tile *tilePtr;
    TkWinDCState state;
    TkWinDrawable *twdPtr;
    XPoint *endPtr, *pointPtr;
    int fillMode;    
    int width, height;
    
    if (drawable == None) {
	return;
    }
    tilePtr = clientPtr->tilePtr;

    /* Determine the bounding box of the polygon. */
    bbox.left = bbox.right = pointArr[0].x;
    bbox.top = bbox.bottom = pointArr[0].y;
    
    endPtr = pointArr + nPoints;
    for (pointPtr = pointArr; pointPtr < endPtr; pointPtr++) {
	if (pointPtr->x < bbox.left) {
	    bbox.left = pointPtr->x;
	} 
	if (pointPtr->x > bbox.right) {
	    bbox.right = pointPtr->x;
	}
	if (pointPtr->y < bbox.top) {
	    bbox.top = pointPtr->y;
	} 
	if (pointPtr->y > bbox.bottom) {
	    bbox.bottom = pointPtr->y;
	}
    }
    width = bbox.right - bbox.left + 1;
    height = bbox.bottom - bbox.top + 1;


    /* Allocate and fill an array of POINTS to create the polygon path. */
    p = winPts = Blt_Malloc(sizeof(POINT) * nPoints);
    for (pointPtr = pointArr; pointPtr < endPtr; pointPtr++) {
	p->x = pointPtr->x - bbox.left;
	p->y = pointPtr->y - bbox.top;
	p++;
    }

    hDC = TkWinGetDrawableDC(Tk_Display(tkwin), drawable, &state);
    SetROP2(hDC, tkpWinRopModes[tilePtr->gc->function]);
    fillMode = (tilePtr->gc->fill_rule == EvenOddRule) ? ALTERNATE : WINDING;
    /* Use the polygon as a clip path. */
    LPtoDP(hDC, winPts, nPoints);
    hRgn = CreatePolygonRgn(winPts, nPoints, fillMode);
    SelectClipRgn(hDC, hRgn);
    OffsetClipRgn(hDC, bbox.left, bbox.top);
    Blt_Free(winPts);

    twdPtr = (TkWinDrawable *)tilePtr->pixmap;
    memDC = CreateCompatibleDC(hDC);
    oldBitmap = SelectBitmap(memDC, twdPtr->bitmap.handle);
    
    /* Tile the bounding box. */
    if (tilePtr->mask != None) {
	TkWinDCState maskState;
	HDC maskDC;

	maskDC = TkWinGetDrawableDC(tilePtr->display, tilePtr->mask, 
	    &maskState);
	SetBkColor(hDC, RGB(255, 255, 255));      
	SetTextColor(hDC, RGB(0, 0, 0));
	TileRegion(memDC, hDC, maskDC, clientPtr, bbox.left, bbox.top, width, 
		   height);
	TkWinReleaseDrawableDC(tilePtr->mask, maskDC, &maskState);
    } else {
	TileRegion(memDC, hDC, NULL, clientPtr, bbox.left, bbox.top, width, 
	   height);
    }
    SelectBitmap(memDC, oldBitmap);
    DeleteDC(memDC);
    SelectClipRgn(hDC, NULL);
    DeleteRgn(hRgn);
    TkWinReleaseDrawableDC(drawable, hDC, &state);
}

void
Blt_TileRectangle(
    Tk_Window tkwin,
    Drawable drawable,
    TileClient *clientPtr,
    int x, int y,
    unsigned int width, 
    unsigned int height)
{
    HBITMAP oldBitmap;
    HDC hDC, memDC;
    Tile *tilePtr;
    TkWinDCState state;
    TkWinDrawable *twdPtr;

    if (drawable == None) {
	return;
    }
    tilePtr = clientPtr->tilePtr;
    hDC = TkWinGetDrawableDC(Tk_Display(tkwin), drawable, &state);
    SetROP2(hDC, tkpWinRopModes[tilePtr->gc->function]);

    twdPtr = (TkWinDrawable *)tilePtr->pixmap;
    memDC = CreateCompatibleDC(hDC);
    oldBitmap = SelectBitmap(memDC, twdPtr->bitmap.handle);

    /* Tile the bounding box. */
    if (tilePtr->mask != None) {
	TkWinDCState maskState;
	HDC maskDC;

	maskDC = TkWinGetDrawableDC(tilePtr->display, tilePtr->mask, 
	    &maskState);
	SetBkColor(hDC, RGB(255, 255, 255));      
	SetTextColor(hDC, RGB(0, 0, 0));
	TileRegion(memDC, hDC, maskDC, clientPtr, x, y, width, height);
	TkWinReleaseDrawableDC(tilePtr->mask, maskDC, &maskState);
    } else {
	TileRegion(memDC, hDC, NULL, clientPtr, x, y, width, height);
    }
    SelectBitmap(memDC, oldBitmap);
    DeleteDC(memDC);
    TkWinReleaseDrawableDC(drawable, hDC, &state);
}

void
Blt_TileRectangles(
    Tk_Window tkwin,
    Drawable drawable,
    TileClient *clientPtr,
    XRectangle rectArr[],
    int nRectangles)
{
    HBITMAP oldBitmap;
    HDC hDC, memDC;
    Tile *tilePtr;
    TkWinDCState state;
    TkWinDrawable *twdPtr;
    XRectangle *rectPtr, *endPtr;

    if (drawable == None) {
	return;
    }
    tilePtr = clientPtr->tilePtr;
    hDC = TkWinGetDrawableDC(Tk_Display(tkwin), drawable, &state);
    SetROP2(hDC, tkpWinRopModes[tilePtr->gc->function]);

    twdPtr = (TkWinDrawable *)tilePtr->pixmap;
    memDC = CreateCompatibleDC(hDC);
    oldBitmap = SelectBitmap(memDC, twdPtr->bitmap.handle);

    endPtr = rectArr + nRectangles;
    /* Tile the bounding box. */
    if (tilePtr->mask != None) {
	TkWinDCState maskState;
	HDC maskDC;

	maskDC = TkWinGetDrawableDC(tilePtr->display, tilePtr->mask, 
	    &maskState);
	SetBkColor(hDC, RGB(255, 255, 255));      
	SetTextColor(hDC, RGB(0, 0, 0));
	for (rectPtr = rectArr; rectPtr < endPtr; rectPtr++) {
	    TileRegion(memDC, hDC, maskDC, clientPtr, (int)rectPtr->x, 
		(int)rectPtr->y, (int)rectPtr->width, (int)rectPtr->height);
	}
	TkWinReleaseDrawableDC(tilePtr->mask, maskDC, &maskState);
    } else {
	for (rectPtr = rectArr; rectPtr < endPtr; rectPtr++) {
	    TileRegion(memDC, hDC, NULL, clientPtr, (int)rectPtr->x, 
		(int)rectPtr->y, (int)rectPtr->width, (int)rectPtr->height);
	}
    }
    SelectBitmap(memDC, oldBitmap);
    DeleteDC(memDC);
    TkWinReleaseDrawableDC(drawable, hDC, &state);
}

#else 

/*
 *----------------------------------------------------------------------
 *
 * RectangleMask --
 *
 *	Creates a rectangular mask also stippled by the mask of the 
 *	tile.  This is used to draw the tiled polygon images with 
 *	transparent areas.
 *
 * Results:
 *	A bitmap mask is returned.
 *
 *----------------------------------------------------------------------
 */
static Pixmap
RectangleMask(display, drawable, x, y, width, height, mask, xOrigin, yOrigin)
    Display *display;
    Drawable drawable;
    int x, y;
    unsigned int width, height;
    Pixmap mask;
    int xOrigin, yOrigin;
{
    GC gc;
    Pixmap bitmap;
    XGCValues gcValues;
    unsigned long gcMask;

    bitmap = Tk_GetPixmap(display, drawable, width, height, 1);
    gcMask = (GCForeground | GCBackground | GCFillStyle | 
	      GCTileStipXOrigin | GCTileStipYOrigin | GCStipple);
    gcValues.foreground = 0x1;
    gcValues.background = 0x0;
    gcValues.fill_style = FillOpaqueStippled;
    gcValues.ts_x_origin = xOrigin - x;
    gcValues.ts_y_origin = yOrigin - y;
    gcValues.stipple = mask;
    gc = XCreateGC(display, bitmap, gcMask, &gcValues);
    XFillRectangle(display, bitmap, gc, 0, 0, width, height);
    Blt_FreePrivateGC(display, gc);
    return bitmap;
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_TileRectangle --
 *
 *	Draws a rectangle filled by a tiled image.  This differs from 
 *	the normal XFillRectangle call in that we also try to handle 
 *	a transparency mask. 
 *
 * Results:
 *	None.
 *
 * Side Effects:
 *	Draws the rectangle.
 *
 *----------------------------------------------------------------------
 */
void
Blt_TileRectangle(
    Tk_Window tkwin,
    Drawable drawable,
    TileClient *clientPtr,
    int x, int y,
    unsigned int width, 
    unsigned int height)
{
    Tile *tilePtr;
    Display *display;

    display = Tk_Display(tkwin);
    tilePtr = clientPtr->tilePtr;
    if (clientPtr->tilePtr->mask != None) {
	Pixmap mask;

	mask = RectangleMask(display, drawable, x, y, width, height,
		tilePtr->mask, clientPtr->xOrigin, clientPtr->yOrigin);
	XSetClipMask(display, tilePtr->gc, mask);
	XSetClipOrigin(display, tilePtr->gc, x, y);
	XFillRectangle(display, drawable, tilePtr->gc, x, y, width, height);
	XSetClipMask(display, tilePtr->gc, None);
	XSetClipOrigin(display, tilePtr->gc, 0, 0);
	Tk_FreePixmap(display, mask);
    } else {
	XFillRectangle(display, drawable, tilePtr->gc, x, y, width, height);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_TileRectangles --
 *
 *	Draws rectangles filled by a tiled image.  This differs from 
 *	the normal XFillRectangles call in that we also try to handle 
 *	a transparency mask. 
 *
 * Results:
 *	None.
 *
 * Side Effects:
 *	Draws the given rectangles.
 *
 *----------------------------------------------------------------------
 */
void
Blt_TileRectangles(
    Tk_Window tkwin,
    Drawable drawable,
    TileClient *clientPtr,
    XRectangle rectArr[],
    int nRectangles)
{
    Tile *tilePtr;

    tilePtr = clientPtr->tilePtr;
    if (tilePtr->mask != None) {
	XRectangle *rectPtr, *endPtr;

	endPtr = rectArr + nRectangles;
	for (rectPtr = rectArr; rectPtr < endPtr; rectPtr++) {
	    Blt_TileRectangle(tkwin, drawable, clientPtr, rectPtr->x, 
		rectPtr->y, rectPtr->width, rectPtr->height);
	}
    } else {
	XFillRectangles(Tk_Display(tkwin), drawable, tilePtr->gc, rectArr, 
		nRectangles);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * PolygonMask --
 *
 *	Creates a polygon shaped mask also stippled by the mask
 *	of the tile.  This is used to draw the tiled polygon images
 *	with transparent areas.
 *
 * Results:
 *	A bitmap mask is returned.
 *
 *----------------------------------------------------------------------
 */
static Pixmap
PolygonMask(display, pointArr, nPoints, regionPtr, mask, xOrigin, yOrigin)
    Display *display;
    XPoint *pointArr;
    int nPoints;
    Region2D *regionPtr;
    Pixmap mask;
    int xOrigin, yOrigin;
{
    unsigned int width, height;
    Pixmap bitmap;
    GC gc;
    XPoint *destArr;
    register XPoint *srcPtr, *destPtr, *endPtr;

    width = regionPtr->right - regionPtr->left + 1;
    height = regionPtr->bottom - regionPtr->top + 1;
    bitmap = 
	Tk_GetPixmap(display, DefaultRootWindow(display), width, height, 1);

    destArr = Blt_Malloc(sizeof(XPoint) * nPoints);
    endPtr = destArr + nPoints;
    srcPtr = pointArr;
    for (destPtr = destArr; destPtr < endPtr; destPtr++) {
	destPtr->x = srcPtr->x - regionPtr->left;
	destPtr->y = srcPtr->y - regionPtr->top;
	srcPtr++;
    }
    gc = XCreateGC(display, bitmap, 0, NULL);
    XFillRectangle(display, bitmap, gc, 0, 0, width, height);
    XSetForeground(display, gc, 0x01);
    XSetFillStyle(display, gc, FillStippled);
    XSetTSOrigin(display, gc, xOrigin - regionPtr->left, 
		 yOrigin - regionPtr->top);
    XSetStipple(display, gc, mask);
    XFillPolygon(display, bitmap, gc, destArr, nPoints, Complex, 
		 CoordModeOrigin);
    XFreeGC(display, gc);
    Blt_Free(destArr);
    return bitmap;
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_TilePolygon --
 *
 *	Draws a polygon filled by a tiled image.  This differs from 
 *	the normal XFillPolygon call in that we also try to handle 
 *	a transparency mask. 
 *
 * Results:
 *	None.
 *
 * Side Effects:
 *	Draws the polygon.
 *
 *----------------------------------------------------------------------
 */
void
Blt_TilePolygon(
    Tk_Window tkwin,
    Drawable drawable,
    TileClient *clientPtr,
    XPoint pointArr[],
    int nPoints)
{
    Tile *tilePtr;
    Display *display;
    
    display = Tk_Display(tkwin);
    tilePtr = clientPtr->tilePtr;
    if (tilePtr->mask != None) {
	XPoint *pointPtr, *endPtr;
	Region2D region;
	Pixmap mask;

	/* Determine the bounding box of the polygon. */
	pointPtr = pointArr;
	region.left = region.right = pointPtr->x;
	region.top = region.bottom = pointPtr->y;
	
	endPtr = pointArr + nPoints;
	for (pointPtr = pointArr; pointPtr < endPtr; pointPtr++) {
	    if (region.left > pointPtr->x) {
		region.left = pointPtr->x;
	    } else if (region.right < pointPtr->x) {
		region.right = pointPtr->x;
	    }
	    if (region.top > pointPtr->y) {
		region.top = pointPtr->y;
	    } else if (region.bottom < pointPtr->y) {
		region.bottom = pointPtr->y;
	    }
	}
	mask = PolygonMask(display, pointArr, nPoints, &region, 
		   tilePtr->mask, clientPtr->xOrigin, clientPtr->yOrigin);
	XSetClipMask(display, tilePtr->gc, mask);
	XSetClipOrigin(display, tilePtr->gc, region.left, region.top);
	XFillPolygon(display, drawable, tilePtr->gc, pointArr, 
		     nPoints, Complex, CoordModeOrigin);
	XSetClipMask(display, tilePtr->gc, None);
	XSetClipOrigin(display, tilePtr->gc, 0, 0);
	Tk_FreePixmap(display, mask);
    } else {
	XFillPolygon(display, drawable, tilePtr->gc, pointArr, 
		     nPoints, Complex, CoordModeOrigin);
    }
}
#endif