/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

#if defined(__APPLE__) && defined(__MACH__)

#include <Carbon/Carbon.h>

#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)

#include <Carbon.h>

#else

#include <Windows.h>

#include <Strings.h>

#endif

#if SDL_MACCLASSIC_GAMMA_SUPPORT

#include <Devices.h>

#include <Files.h>

#include <MacTypes.h>

#include <QDOffscreen.h>

#include <Quickdraw.h>

#include <Video.h>

#endif

#include "SDL_stdinc.h"

#include "SDL_macwm_c.h"

void Mac_SetCaption(_THIS, const char *title, const char *icon)

{

	/* Don't convert C to P string in place, because it may be read-only */

	Str255		ptitle; /* MJS */

	ptitle[0] = strlen (title);

	SDL_memcpy(ptitle+1, title, ptitle[0]); /* MJS */

	if (SDL_Window)

		SetWTitle(SDL_Window, ptitle); /* MJS */

}

#if SDL_MACCLASSIC_GAMMA_SUPPORT

/*

 * ADC Gamma Ramp support...

 *

 * Mac Gamma Ramp code was originally from sample code provided by

 *  Apple Developer Connection, and not written specifically for SDL:

 * "Contains: Functions to enable Mac OS device gamma adjustments using 3 channel 256 element 8 bit gamma ramps

 *  Written by: Geoff Stahl (ggs)

 *  Copyright: Copyright (c) 1999 Apple Computer, Inc., All Rights Reserved

 *  Disclaimer: You may incorporate this sample code into your applications without

 *              restriction, though the sample code has been provided "AS IS" and the

 *              responsibility for its operation is 100% yours.  However, what you are

 *              not permitted to do is to redistribute the source as "DSC Sample Code"

 *              after having made changes. If you're going to re-distribute the source,

 *              we require that you make it clear in the source that the code was

 *              descended from Apple Sample Code, but that you've made changes."

 * (The sample code has been integrated into this file, and thus is modified from the original Apple sources.)

 */

typedef struct recDeviceGamma											/* storage for device handle and gamma table */

{

	GDHandle hGD;												/* handle to device */

	GammaTblPtr pDeviceGamma;									/* pointer to device gamma table */

} recDeviceGamma;

typedef recDeviceGamma * precDeviceGamma;

typedef struct recSystemGamma											/* storage for system devices and gamma tables */

{

	short numDevices;											/* number of devices */

	precDeviceGamma * devGamma;									/* array of pointers to device gamma records */

} recSystemGamma;

typedef recSystemGamma * precSystemGamma;

static Ptr CopyGammaTable (GammaTblPtr pTableGammaIn)

{

	GammaTblPtr		pTableGammaOut = NULL;

	short			tableSize, dataWidth;

	if (pTableGammaIn)												/* if there is a table to copy  */

	{

		dataWidth = (pTableGammaIn->gDataWidth + 7) / 8;			/* number of bytes per entry */

		tableSize = sizeof (GammaTbl) + pTableGammaIn->gFormulaSize +

					(pTableGammaIn->gChanCnt * pTableGammaIn->gDataCnt * dataWidth);

		pTableGammaOut = (GammaTblPtr) NewPtr (tableSize);			/* allocate new table */

		if (pTableGammaOut)											

			BlockMove( (Ptr)pTableGammaIn, (Ptr)pTableGammaOut, tableSize);	/* move everything */

	}

	return (Ptr)pTableGammaOut;										/* return whatever we allocated, could be NULL */

}

static OSErr GetGammaTable (GDHandle hGD, GammaTblPtr * ppTableGammaOut)

{

	VDGammaRecord   DeviceGammaRec;

	CntrlParam		cParam;

	OSErr			err;

	cParam.ioCompletion = NULL;										/* set up control params */

	cParam.ioNamePtr = NULL;

	cParam.ioVRefNum = 0;

	cParam.ioCRefNum = (**hGD).gdRefNum;

	cParam.csCode = cscGetGamma;									/* Get Gamma commnd to device */

	*(Ptr *)cParam.csParam = (Ptr) &DeviceGammaRec;					/* record for gamma */

	err = PBStatusSync( (ParmBlkPtr)&cParam );						/* get gamma */

	*ppTableGammaOut = (GammaTblPtr)(DeviceGammaRec.csGTable);		/* pull table out of record */

	return err;	

}

static Ptr GetDeviceGamma (GDHandle hGD)

{

	GammaTblPtr		pTableGammaDevice = NULL;

	GammaTblPtr		pTableGammaReturn = NULL;	

	OSErr			err;

	err = GetGammaTable (hGD, &pTableGammaDevice);					/* get a pointer to the devices table */

	if ((noErr == err) && pTableGammaDevice)						/* if succesful */

		pTableGammaReturn = (GammaTblPtr) CopyGammaTable (pTableGammaDevice); /* copy to global */

	return (Ptr) pTableGammaReturn;

}

static void DisposeGammaTable (Ptr pGamma)

{

	if (pGamma)

		DisposePtr((Ptr) pGamma);									/* get rid of it */

}

static void DisposeSystemGammas (Ptr* ppSystemGammas)

{

	precSystemGamma pSysGammaIn;

	if (ppSystemGammas)

	{

		pSysGammaIn = (precSystemGamma) *ppSystemGammas;

		if (pSysGammaIn)

		{

			short i;

			for (i = 0; i < pSysGammaIn->numDevices; i++)		/* for all devices */

				if (pSysGammaIn->devGamma [i])						/* if pointer is valid */

				{

					DisposeGammaTable ((Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma); /* dump gamma table */

					DisposePtr ((Ptr) pSysGammaIn->devGamma [i]);					   /* dump device info */

				}

			DisposePtr ((Ptr) pSysGammaIn->devGamma);				/* dump device pointer array		 */

			DisposePtr ((Ptr) pSysGammaIn);							/* dump system structure */

			*ppSystemGammas = NULL;

		}	

	}

}

static Boolean GetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)

{

	GammaTblPtr		pTableGammaTemp = NULL;

	long 			indexChan, indexEntry;

	OSErr			err;

	if (pRamp)															/* ensure pRamp is allocated */

	{

		err = GetGammaTable (hGD, &pTableGammaTemp);					/* get a pointer to the current gamma */

		if ((noErr == err) && pTableGammaTemp)							/* if successful */

		{															

			/* fill ramp */

			unsigned char * pEntry = (unsigned char *) &pTableGammaTemp->gFormulaData + pTableGammaTemp->gFormulaSize; /* base of table */

			short bytesPerEntry = (pTableGammaTemp->gDataWidth + 7) / 8; /* size, in bytes, of the device table entries */

			short shiftRightValue = pTableGammaTemp->gDataWidth - 8; 	 /* number of right shifts device -> ramp */

			short channels = pTableGammaTemp->gChanCnt;	

			short entries = pTableGammaTemp->gDataCnt;									

			if (3 == channels)											/* RGB format */

			{															/* note, this will create runs of entries if dest. is bigger (not linear interpolate) */

				for (indexChan = 0; indexChan < channels; indexChan++)

					for (indexEntry = 0; indexEntry < 256; indexEntry++)

						*((unsigned char *) pRamp + (indexChan * 256) + indexEntry) = 

						  *(pEntry + indexChan * entries * bytesPerEntry + indexEntry * entries * bytesPerEntry / 256) >> shiftRightValue;

			}

			else														/* single channel format */

			{

				for (indexChan = 0; indexChan < 768; indexChan += 256)	/* repeat for all 3 channels (step by ramp size) */

					for (indexEntry = 0; indexEntry < 256; indexEntry++) /* for all entries set vramp value */

						*((unsigned char *) pRamp + indexChan + indexEntry) = 

						  *(pEntry + indexEntry * entries * bytesPerEntry / 256) >> shiftRightValue;

			}

			return true;

		}

	}

	return false;

}

static Ptr GetSystemGammas (void)

{

	precSystemGamma pSysGammaOut;									/* return pointer to system device gamma info */

	short devCount = 0;												/* number of devices attached */

	Boolean fail = false;

	GDHandle hGDevice;

	pSysGammaOut = (precSystemGamma) NewPtr (sizeof (recSystemGamma)); /* allocate for structure */

	hGDevice = GetDeviceList ();							/* top of device list */

	do																/* iterate */

	{

		devCount++;													/* count devices					 */

		hGDevice = GetNextDevice (hGDevice);						/* next device */

	} while (hGDevice);

	pSysGammaOut->devGamma = (precDeviceGamma *) NewPtr (sizeof (precDeviceGamma) * devCount); /* allocate for array of pointers to device records */

	if (pSysGammaOut)

	{

		pSysGammaOut->numDevices = devCount;						/* stuff count */

		devCount = 0;												/* reset iteration */

		hGDevice = GetDeviceList ();

		do

		{

			pSysGammaOut->devGamma [devCount] = (precDeviceGamma) NewPtr (sizeof (recDeviceGamma));	  /* new device record */

			if (pSysGammaOut->devGamma [devCount])					/* if we actually allocated memory */

			{

				pSysGammaOut->devGamma [devCount]->hGD = hGDevice;										  /* stuff handle */

				pSysGammaOut->devGamma [devCount]->pDeviceGamma = (GammaTblPtr)GetDeviceGamma (hGDevice); /* copy gamma table */

			}

			else													/* otherwise dump record on exit */

			 fail = true;

			devCount++;												/* next device */

			hGDevice = GetNextDevice (hGDevice);						

		} while (hGDevice);

	}

	if (!fail)														/* if we did not fail */

		return (Ptr) pSysGammaOut;									/* return pointer to structure */

	else

	{

		DisposeSystemGammas ((Ptr *) &pSysGammaOut);					/* otherwise dump the current structures (dispose does error checking) */

		return NULL;												/* could not complete */

	}

}

static void RestoreDeviceGamma (GDHandle hGD, Ptr pGammaTable)

{

	VDSetEntryRecord setEntriesRec;

	VDGammaRecord	gameRecRestore;

	CTabHandle      hCTabDeviceColors;

	Ptr				csPtr;

	OSErr			err = noErr;

	if (pGammaTable)												/* if we have a table to restore								 */

	{

		gameRecRestore.csGTable = pGammaTable;						/* setup restore record */

		csPtr = (Ptr) &gameRecRestore;

		err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);	/* restore gamma */

		if ((noErr == err) && (8 == (**(**hGD).gdPMap).pixelSize))	/* if successful and on an 8 bit device */

		{

			hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;			/* do SetEntries to force CLUT update */

			setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;

			setEntriesRec.csStart = 0;

			setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;

			csPtr = (Ptr) &setEntriesRec;

			err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); /* SetEntries in CLUT */

		}

	}

}

static void RestoreSystemGammas (Ptr pSystemGammas)

{

	short i;

	precSystemGamma pSysGammaIn = (precSystemGamma) pSystemGammas;

	if (pSysGammaIn)

		for (i = 0; i < pSysGammaIn->numDevices; i++)			/* for all devices */

			RestoreDeviceGamma (pSysGammaIn->devGamma [i]->hGD, (Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma);	/* restore gamma */

}

static Ptr CreateEmptyGammaTable (short channels, short entries, short bits)

{

	GammaTblPtr		pTableGammaOut = NULL;

	short			tableSize, dataWidth;

	dataWidth = (bits + 7) / 8;										/* number of bytes per entry */

	tableSize = sizeof (GammaTbl) + (channels * entries * dataWidth);

	pTableGammaOut = (GammaTblPtr) NewPtrClear (tableSize);			/* allocate new tabel */

	if (pTableGammaOut)												/* if we successfully allocated */

	{

		pTableGammaOut->gVersion = 0;								/* set parameters based on input */

		pTableGammaOut->gType = 0;

		pTableGammaOut->gFormulaSize = 0;

		pTableGammaOut->gChanCnt = channels;

		pTableGammaOut->gDataCnt = entries;

		pTableGammaOut->gDataWidth = bits;

	}

	return (Ptr)pTableGammaOut;										/* return whatever we allocated */

}

static Boolean SetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)

{

	VDSetEntryRecord setEntriesRec;

	VDGammaRecord	gameRecRestore;

	GammaTblPtr		pTableGammaNew;

	GammaTblPtr		pTableGammaCurrent = NULL;

	CTabHandle      hCTabDeviceColors;

	Ptr				csPtr;

	OSErr			err;

	short 			dataBits, entries, channels = 3;						/* force three channels in the gamma table */

	if (pRamp)																/* ensure pRamp is allocated */

	{

		err= GetGammaTable (hGD, &pTableGammaCurrent);						/* get pointer to current table */

		if ((noErr == err) && pTableGammaCurrent)

		{

			dataBits = pTableGammaCurrent->gDataWidth;						/* table must have same data width */

			entries = pTableGammaCurrent->gDataCnt;							/* table must be same size */

			pTableGammaNew = (GammaTblPtr) CreateEmptyGammaTable (channels, entries, dataBits); /* our new table */

			if (pTableGammaNew)												/* if successful fill table */

			{	

				unsigned char * pGammaBase = (unsigned char *) &pTableGammaNew->gFormulaData + pTableGammaNew->gFormulaSize; /* base of table */

				if ((256 == entries) && (8 == dataBits)) 						/* simple case: direct mapping */

					BlockMove ((Ptr)pRamp, (Ptr)pGammaBase, channels * entries); /* move everything */

				else														/* tough case handle entry, channel and data size disparities */

				{

					short indexChan, indexEntry;

					short bytesPerEntry = (dataBits + 7) / 8; 				/* size, in bytes, of the device table entries */

					short shiftRightValue = 8 - dataBits;					/* number of right shifts ramp -> device */

					shiftRightValue += ((bytesPerEntry - 1) * 8);  			/* multibyte entries and the need to map a byte at a time most sig. to least sig. */

					for (indexChan = 0; indexChan < channels; indexChan++) /* for all the channels */

						for (indexEntry = 0; indexEntry < entries; indexEntry++) /* for all the entries */

						{

							short currentShift = shiftRightValue;			/* reset current bit shift */

							long temp = *((unsigned char *)pRamp + (indexChan << 8) + (indexEntry << 8) / entries); /* get data from ramp */

							short indexByte;

							for (indexByte = 0; indexByte < bytesPerEntry; indexByte++) /* for all bytes */

							{

								if (currentShift < 0)						/* shift data correctly for current byte */

									*(pGammaBase++) = temp << -currentShift;

								else

									*(pGammaBase++) = temp >> currentShift;

								currentShift -= 8;							/* increment shift to align to next less sig. byte */

							}

						}

				}

				/* set gamma */

				gameRecRestore.csGTable = (Ptr) pTableGammaNew;				/* setup restore record */

				csPtr = (Ptr) &gameRecRestore;

				err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);	/* restore gamma (note, display drivers may delay returning from this until VBL) */

				if ((8 == (**(**hGD).gdPMap).pixelSize) && (noErr == err))	/* if successful and on an 8 bit device */

				{

					hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;			/* do SetEntries to force CLUT update */

					setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;

					setEntriesRec.csStart = 0;

					setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;

					csPtr = (Ptr) &setEntriesRec;

					err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr);	/* SetEntries in CLUT */

				}

				DisposeGammaTable ((Ptr) pTableGammaNew);					/* dump table */

				if (noErr == err)

					return true;

			}

		}

	}

	else																	/* set NULL gamma -> results in linear map */

	{

		gameRecRestore.csGTable = (Ptr) NULL;								/* setup restore record */

		csPtr = (Ptr) &gameRecRestore;

		err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);			/* restore gamma */

		if ((8 == (**(**hGD).gdPMap).pixelSize) && (noErr == err))			/* if successful and on an 8 bit device */

		{

			hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;					/* do SetEntries to force CLUT update */

			setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;

			setEntriesRec.csStart = 0;

			setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;

			csPtr = (Ptr) &setEntriesRec;

			err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr);	/* SetEntries in CLUT */

		}

		if (noErr == err)

			return true;

	}

	return false;															/* memory allocation or device control failed if we get here */

}

/* end of ADC Gamma Ramp support code... */

static Ptr systemGammaPtr;

void Mac_QuitGamma(_THIS)

{

	if (systemGammaPtr)

	{

		RestoreSystemGammas(systemGammaPtr);

		DisposeSystemGammas(&systemGammaPtr);

	}

}

static unsigned char shiftedRamp[3 * 256];

int Mac_SetGammaRamp(_THIS, Uint16 *ramp)

{

	int i;

	if (!systemGammaPtr)

		systemGammaPtr = GetSystemGammas();

	for (i = 0; i < 3 * 256; i++)

	{

		shiftedRamp[i] = ramp[i] >> 8;

	}

	if (SetDeviceGammaRampGD(GetMainDevice(), (Ptr) shiftedRamp))

		return 0;

	else

		return -1;

}

int Mac_GetGammaRamp(_THIS, Uint16 *ramp)

{

	if (GetDeviceGammaRampGD(GetMainDevice(), (Ptr) shiftedRamp))

	{

		int i;

		for (i = 0; i < 3 * 256; i++)

		{

			ramp[i] = shiftedRamp[i] << 8;

		}

		return 0;

	}

	else

		return -1;

}

#endif  /* SDL_MACCLASSIC_GAMMA_SUPPORT */