/*
 * Prototypes for local functions:
 */

static void		ImageTypeThreadExitProc(ClientData clientData);
static void		DeleteImage(char *blockPtr);
static void		NullChangeProc(ClientData clientData, int x, int y,
			    int width, int height,
			    int imageWidth, int imageHeight);
static void		EventuallyDeleteImage(ImageModel *modelPtr,
			    int forgetImageHashNow);

/*
 *----------------------------------------------------------------------
 *
 * ImageTypeThreadExitProc --

	     * Need to check if the _command_ that we are about to create is
	     * the name of the current model widget command (normally "." but
	     * could have been renamed) and fail in that case before a really
	     * nasty and hard to stop crash happens.
	     */

	    topWin = (TkWindow *) TkToplevelWindowForCommand(interp, name);
	    if ((topWin != NULL) && (winPtr->mainPtr->winPtr == topWin)) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"images may not be named the same as the main window",
			-1));
		Tcl_SetErrorCode(interp, "TK", "IMAGE", "SMASH_MAIN", NULL);
		return TCL_ERROR;
	    }
	}

    if (interp) {
	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		"image \"%s\" doesn't exist", name));
	Tcl_SetErrorCode(interp, "TK", "LOOKUP", "IMAGE", name, NULL);
    }
    return NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * TkImageForWindow --
 *
 *	This function is invoked to retrieve an image for a particular
 *	window.
 *
 * Results:
 *	The return value is a token for the image. This is allocated
 *	when the input image does not already refer to the window, so
 *	the caller must test for the result being equal with the input
 *	image in order to decide if a Tk_FreeImage() is required.
 *
 * Side effects:
 *	See Tk_GetImage().
 *
 *----------------------------------------------------------------------
 */

Tk_Image
TkImageForWindow(
    Tk_Image image,		/* The input image. */
    Tk_Window tkwin)		/* Token for window in which image will be
				 * used. */
{
    Image *imagePtr = (Image *) image;
    ImageModel *modelPtr = imagePtr->modelPtr;

    if (imagePtr->tkwin == tkwin) {
	return image;
    }
    if (modelPtr->typePtr == NULL) {
	return NULL;
    }
    if (modelPtr->deleted) {
	return NULL;
    }
    imagePtr = (Image *) ckalloc(sizeof(Image));
    imagePtr->tkwin = tkwin;
    imagePtr->display = Tk_Display(tkwin);
    imagePtr->modelPtr = modelPtr;
    imagePtr->instanceData =
	    modelPtr->typePtr->getProc(tkwin, modelPtr->modelData);
    imagePtr->changeProc = NullChangeProc;
    imagePtr->widgetClientData = NULL;
    imagePtr->nextPtr = modelPtr->instancePtr;
    modelPtr->instancePtr = imagePtr;
    return (Tk_Image) imagePtr;
}

static void
NullChangeProc(ClientData clientData, int x, int y, int width, int height,
    int imageWidth, int imageHeight)
{
}

/*
 *----------------------------------------------------------------------
 *
 * TkImageEqual --
 *
 *	Are two images equal, i.e. referring to the same model?
 *
 * Results:
 *	True or false.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

int
TkImageEqual(Tk_Image image1, Tk_Image image2)
{
    Image *image1Ptr = (Image *) image1;
    Image *image2Ptr = (Image *) image2;

    if ((image1Ptr != NULL) && (image2Ptr != NULL)) {
	return (image1Ptr->modelPtr == image2Ptr->modelPtr);
    }
    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * Tk_FreeImage --
 *
 *	This function is invoked by a widget when it no longer needs an image

MODULE_SCOPE int	TkInitFontchooser(Tcl_Interp *interp,
			    ClientData clientData);
MODULE_SCOPE void	TkpWarpPointer(TkDisplay *dispPtr);
MODULE_SCOPE void	TkpCancelWarp(TkDisplay *dispPtr);
MODULE_SCOPE int	TkListCreateFrame(ClientData clientData,
			    Tcl_Interp *interp, Tcl_Obj *listObj,
			    int toplevel, Tcl_Obj *nameObj);
MODULE_SCOPE Tk_Image	TkImageForWindow(Tk_Image image, Tk_Window tkwin);
MODULE_SCOPE int	TkImageEqual(Tk_Image image1, Tk_Image image2);

#ifdef PLATFORM_SDL
MODULE_SCOPE int	TkInitSdltkCmd(Tcl_Interp *interp,
			    ClientData clientData);
#endif

#if defined(_WIN32) && !defined(PLATFORM_SDL)
#define TkParseColor XParseColor

 */

#include "tkInt.h"
#include "ttkTheme.h"

#undef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))

#if defined(PLATFORM_SDL) || defined(_WIN32) || defined(MAC_OSX_TK)
#   define NEED_EXTRA_INFO 0
#else
    /*
     * Images are to be managed per Tk_Window to take the Display
     * into account.
     */
#   define NEED_EXTRA_INFO 1
#endif


/*------------------------------------------------------------------------
 * +++ ImageSpec management.
 */

struct TtkImageSpec {
    Tk_Image 		baseImage;	/* Base image to use */
    int 		mapCount;	/* #state-specific overrides */
    Ttk_StateSpec	*states;	/* array[mapCount] of states ... */
    Tk_Image		*images;	/* ... per-state images to use */
    Tk_ImageChangedProc *imageChanged;
    ClientData		imageChangedClientData;
#if NEED_EXTRA_INFO
    Tk_Image 		useImage;
#endif
};

/* NullImageChanged --
 * 	Do-nothing Tk_ImageChangedProc.
 */
static void NullImageChanged(ClientData clientData,
    int x, int y, int width, int height, int imageWidth, int imageHeight)

    imageSpec = ckalloc(sizeof(*imageSpec));
    imageSpec->baseImage = 0;
    imageSpec->mapCount = 0;
    imageSpec->states = 0;
    imageSpec->images = 0;
    imageSpec->imageChanged = imageChangedProc;
    imageSpec->imageChangedClientData = imageChangedClientData;
#if NEED_EXTRA_INFO
    imageSpec->useImage = 0;
#endif

    if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) {
	goto error;
    }

    if ((objc % 2) != 1) {
	if (interp) {

    for (i=0; i < imageSpec->mapCount; ++i) {
	Tk_FreeImage(imageSpec->images[i]);
    }

    if (imageSpec->baseImage) { Tk_FreeImage(imageSpec->baseImage); }
    if (imageSpec->states) { ckfree(imageSpec->states); }
    if (imageSpec->images) { ckfree(imageSpec->images); }
#if NEED_EXTRA_INFO
    if (imageSpec->useImage) { Tk_FreeImage(imageSpec->useImage); }
#endif

    ckfree(imageSpec);
}

/* TtkSelectImage --
 * 	Return a state-specific image from an ImageSpec
 */
Tk_Image TtkSelectImage(Ttk_ImageSpec *imageSpec, Tk_Window tkwin,
    Ttk_State state)
{
    Tk_Image result = 0;
#if NEED_EXTRA_INFO
    Tk_Image image;
#endif
    int i;
    for (i = 0; i < imageSpec->mapCount; ++i) {
	if (Ttk_StateMatches(state, imageSpec->states+i)) {
	    result = imageSpec->images[i];
	    break;
	}
    }
    if (!result) {
	result = imageSpec->baseImage;
    }
#if NEED_EXTRA_INFO
    if (tkwin) {
	image = TkImageForWindow(result, tkwin);
	if (image != result) {
	    if (imageSpec->useImage) {
		Tk_FreeImage(imageSpec->useImage);
	    }
	    imageSpec->useImage = image;
	    if (image) {
		result = image;
	    }
	}
    }
#endif
    return result;
}

/*------------------------------------------------------------------------
 * +++ Drawing utilities.
 */

/* LPadding, CPadding, RPadding --

    if (imageData->imageMap) {
	Tcl_Obj *imageObj = Ttk_StateMapLookup(NULL,imageData->imageMap,state);
	if (imageObj) {
	    image = Ttk_UseImage(imageData->cache, tkwin, imageObj);
	}
    }
    if (!image) {
	image = TtkSelectImage(imageData->imageSpec, tkwin, state);
    }
#else
    image = TtkSelectImage(imageData->imageSpec, tkwin, state);
#endif

    if (!image) {
	return;
    }

    Tk_SizeOfImage(image, &imgWidth, &imgHeight);

    if (!image->imageObj) {
	return 0;
    }
    image->imageSpec = TtkGetImageSpec(NULL, tkwin, image->imageObj);
    if (!image->imageSpec) {
	return 0;
    }
    image->tkimg = TtkSelectImage(image->imageSpec, tkwin, state);
    if (!image->tkimg) {
	TtkFreeImageSpec(image->imageSpec);
	return 0;
    }
    Tk_SizeOfImage(image->tkimg, &image->width, &image->height);

    return 1;

     * @@@ it's ugly and out of fashion.
     * Do not stipple at all under Aqua, just draw the image: it shows up
     * as a white rectangle otherwise.
     */


    if (state & TTK_STATE_DISABLED) {
	if (TkImageEqual(TtkSelectImage(image->imageSpec, 0, 0ul),
		image->tkimg)) {
#ifndef MAC_OSX_TK
	    StippleOver(image, tkwin, d, b.x,b.y);
#endif
	}
    }
}

 */

typedef struct TtkImageSpec Ttk_ImageSpec;
TTKAPI Ttk_ImageSpec *TtkGetImageSpec(Tcl_Interp *, Tk_Window, Tcl_Obj *);
TTKAPI Ttk_ImageSpec *TtkGetImageSpecEx(Tcl_Interp *, Tk_Window, Tcl_Obj *,
					Tk_ImageChangedProc *, ClientData);
TTKAPI void TtkFreeImageSpec(Ttk_ImageSpec *);
TTKAPI Tk_Image TtkSelectImage(Ttk_ImageSpec *, Tk_Window, Ttk_State);

/*------------------------------------------------------------------------
 * +++ Miscellaneous enumerations.
 * 	Other stuff that element implementations need to know about.
 */
typedef enum 			/* -default option values */
{