1 files changed, 92 insertions, 90 deletions

diff --git a/engines/tinsel/palette.cpp b/engines/tinsel/palette.cpp
index a0ceec54eb..0877337603 100644
--- a/engines/tinsel/palette.cpp
+++ b/engines/tinsel/palette.cpp
@@ -32,6 +32,8 @@
 #include "tinsel/tinsel.h"
 
 #include "common/system.h"
+#include "common/textconsole.h"
+#include "graphics/palette.h"
 
 namespace Tinsel {
 
@@ -41,12 +43,12 @@ namespace Tinsel {
 struct VIDEO_DAC_Q {
 	union {
 		SCNHANDLE hRGBarray;	///< handle of palette or
-		COLORREF *pRGBarray;	///< list of palette colours
+		COLORREF *pRGBarray;	///< list of palette colors
 		COLORREF  singleRGB;
 	} pal;
 	bool bHandle;		///< when set - use handle of palette
 	int destDACindex;	///< start index of palette in video DAC
-	int numColours;		///< number of colours in "hRGBarray"
+	int numColors;		///< number of colors in "hRGBarray"
 };
 
 
@@ -67,13 +69,13 @@ static VIDEO_DAC_Q vidDACdata[VDACQLENGTH];
 /** video DAC transfer Q head pointer */
 static VIDEO_DAC_Q *pDAChead;
 
-/** colour index of the 4 colours used for the translucent palette */
+/** color index of the 4 colors used for the translucent palette */
 #define COL_HILIGHT	TBLUE1
 
 /** the translucent palette lookup table */
-uint8 transPalette[MAX_COLOURS];	// used in graphics.cpp
+uint8 transPalette[MAX_COLORS];	// used in graphics.cpp
 
-uint8 ghostPalette[MAX_COLOURS];
+uint8 ghostPalette[MAX_COLORS];
 
 static int translucentIndex	= 228;
 
@@ -111,7 +113,7 @@ void psxPaletteMapper(PALQ *originalPal, uint8 *psxClut, byte *mapperTable) {
 			}
 
 			// Check for correspondent color
-			for (uint i = 0; (i < FROM_LE_32(pal->numColours)) && !colorFound; i++) {
+			for (uint i = 0; (i < FROM_LE_32(pal->numColors)) && !colorFound; i++) {
 				// get R G B values in the same way as psx format converters
 				uint16 psxEquivalent = TINSEL_PSX_RGB(TINSEL_GetRValue(pal->palRGB[i]) >> 3, TINSEL_GetGValue(pal->palRGB[i]) >> 3, TINSEL_GetBValue(pal->palRGB[i]) >> 3);
 
@@ -138,15 +140,15 @@ void PalettesToVideoDAC() {
 	// while Q is not empty
 	while (pDAChead != pDACtail) {
 		const PALETTE *pPalette;	// pointer to hardware palette
-		const COLORREF *pColours;	// pointer to list of RGB triples
+		const COLORREF *pColors;	// pointer to list of RGB triples
 
 #ifdef	DEBUG
 		// make sure palette does not overlap
-		assert(pDACtail->destDACindex + pDACtail->numColours <= MAX_COLOURS);
+		assert(pDACtail->destDACindex + pDACtail->numColors <= MAX_COLORS);
 #else
 		// make sure palette does not overlap
-		if (pDACtail->destDACindex + pDACtail->numColours > MAX_COLOURS)
-			pDACtail->numColours = MAX_COLOURS - pDACtail->destDACindex;
+		if (pDACtail->destDACindex + pDACtail->numColors > MAX_COLORS)
+			pDACtail->numColors = MAX_COLORS - pDACtail->destDACindex;
 #endif
 
 		if (pDACtail->bHandle) {
@@ -156,23 +158,23 @@ void PalettesToVideoDAC() {
 			pPalette = (const PALETTE *)LockMem(pDACtail->pal.hRGBarray);
 
 			// get RGB pointer
-			pColours = pPalette->palRGB;
-		} else if (pDACtail->numColours == 1) {
+			pColors = pPalette->palRGB;
+		} else if (pDACtail->numColors == 1) {
 			// we are using a single color palette
-			pColours = &pDACtail->pal.singleRGB;
+			pColors = &pDACtail->pal.singleRGB;
 		} else {
 			// we are using a palette pointer
-			pColours = pDACtail->pal.pRGBarray;
+			pColors = pDACtail->pal.pRGBarray;
 		}
 
-		for (int i = 0; i < pDACtail->numColours; ++i) {
-			pal[i * 3 + 0] = TINSEL_GetRValue(pColours[i]);
-			pal[i * 3 + 1] = TINSEL_GetGValue(pColours[i]);
-			pal[i * 3 + 2] = TINSEL_GetBValue(pColours[i]);
+		for (int i = 0; i < pDACtail->numColors; ++i) {
+			pal[i * 3 + 0] = TINSEL_GetRValue(pColors[i]);
+			pal[i * 3 + 1] = TINSEL_GetGValue(pColors[i]);
+			pal[i * 3 + 2] = TINSEL_GetBValue(pColors[i]);
 		}
 
 		// update the system palette
-		g_system->getPaletteManager()->setPalette(pal, pDACtail->destDACindex, pDACtail->numColours);
+		g_system->getPaletteManager()->setPalette(pal, pDACtail->destDACindex, pDACtail->numColors);
 
 		// update tail pointer
 		pDACtail++;
@@ -216,15 +218,15 @@ void PaletteStats() {
 /**
  * Places a palette in the video DAC queue.
  * @param posInDAC			Position in video DAC
- * @param numColours		Number of colours in palette
+ * @param numColors		Number of colors in palette
  * @param hPalette			Handle to palette
  */
-void UpdateDACqueueHandle(int posInDAC, int numColours, SCNHANDLE hPalette) {
+void UpdateDACqueueHandle(int posInDAC, int numColors, SCNHANDLE hPalette) {
 	// check Q overflow
 	assert(pDAChead < vidDACdata + VDACQLENGTH);
 
 	pDAChead->destDACindex = posInDAC & ~PALETTE_MOVED;	// set index in video DAC
-	pDAChead->numColours = numColours;	// set number of colours
+	pDAChead->numColors = numColors;	// set number of colors
 	pDAChead->pal.hRGBarray = hPalette;	// set handle of palette
 	pDAChead->bHandle = true;		// we are using a palette handle
 
@@ -240,19 +242,19 @@ void UpdateDACqueueHandle(int posInDAC, int numColours, SCNHANDLE hPalette) {
 /**
  * Places a palette in the video DAC queue.
  * @param posInDAC			Position in video DAC
- * @param numColours		Number of colours in palette
- * @param pColours			List of RGB triples
+ * @param numColors		Number of colors in palette
+ * @param pColors			List of RGB triples
  */
-void UpdateDACqueue(int posInDAC, int numColours, COLORREF *pColours) {
+void UpdateDACqueue(int posInDAC, int numColors, COLORREF *pColors) {
 	// check Q overflow
 	assert(pDAChead < vidDACdata + NUM_PALETTES);
 
 	pDAChead->destDACindex = posInDAC & ~PALETTE_MOVED;	// set index in video DAC
-	pDAChead->numColours = numColours;	// set number of colours
-	if (numColours == 1)
-		pDAChead->pal.singleRGB = *pColours;	// set single color of which the "palette" consists
+	pDAChead->numColors = numColors;	// set number of colors
+	if (numColors == 1)
+		pDAChead->pal.singleRGB = *pColors;	// set single color of which the "palette" consists
 	else
-		pDAChead->pal.pRGBarray = pColours;	// set addr of palette
+		pDAChead->pal.pRGBarray = pColors;	// set addr of palette
 	pDAChead->bHandle = false;		// we are not using a palette handle
 
 	// update head pointer
@@ -275,7 +277,7 @@ void UpdateDACqueue(int posInDAC, COLORREF color) {
 	assert(pDAChead < vidDACdata + NUM_PALETTES);
 
 	pDAChead->destDACindex = posInDAC & ~PALETTE_MOVED;	// set index in video DAC
-	pDAChead->numColours = 1;	// set number of colours
+	pDAChead->numColors = 1;	// set number of colors
 	pDAChead->pal.singleRGB = color;	// set single color of which the "palette" consists
 	pDAChead->bHandle = false;		// we are not using a palette handle
 
@@ -294,7 +296,7 @@ void UpdateDACqueue(int posInDAC, COLORREF color) {
  */
 PALQ *AllocPalette(SCNHANDLE hNewPal) {
 	PALQ *pPrev, *p;		// walks palAllocData
-	int iDAC;		// colour index in video DAC
+	int iDAC;		// color index in video DAC
 	PALQ *pNxtPal;		// next PALQ struct in palette allocator
 	PALETTE *pNewPal;
 
@@ -311,7 +313,7 @@ PALQ *AllocPalette(SCNHANDLE hNewPal) {
 	}
 
 	// search all structs in palette allocator - find a free slot
-	iDAC = FGND_DAC_INDEX;	// init DAC index to first available foreground colour
+	iDAC = FGND_DAC_INDEX;	// init DAC index to first available foreground color
 
 	for (p = palAllocData; p < palAllocData + NUM_PALETTES; p++) {
 		if (p->hPal == 0) {
@@ -319,11 +321,11 @@ PALQ *AllocPalette(SCNHANDLE hNewPal) {
 			p->objCount = 1;	// init number of objects using palette
 			p->posInDAC = iDAC;	// set palettes start pos in video DAC
 			p->hPal = hNewPal;	// set hardware palette data
-			p->numColours = FROM_LE_32(pNewPal->numColours);	// set number of colours in palette
+			p->numColors = FROM_LE_32(pNewPal->numColors);	// set number of colors in palette
 
 			if (TinselV2)
-				// Copy all the colours
-				memcpy(p->palRGB, pNewPal->palRGB, p->numColours * sizeof(COLORREF));
+				// Copy all the colors
+				memcpy(p->palRGB, pNewPal->palRGB, p->numColors * sizeof(COLORREF));
 
 #ifdef DEBUG
 			// one more palette in use
@@ -333,30 +335,30 @@ PALQ *AllocPalette(SCNHANDLE hNewPal) {
 
 			// Q the change to the video DAC
 			if (TinselV2)
-				UpdateDACqueue(p->posInDAC, p->numColours, p->palRGB);
+				UpdateDACqueue(p->posInDAC, p->numColors, p->palRGB);
 			else
-				UpdateDACqueueHandle(p->posInDAC, p->numColours, p->hPal);
+				UpdateDACqueueHandle(p->posInDAC, p->numColors, p->hPal);
 
 			// move all palettes after this one down (if necessary)
 			for (pPrev = p, pNxtPal = pPrev + 1; pNxtPal < palAllocData + NUM_PALETTES; pNxtPal++) {
 				if (pNxtPal->hPal != 0) {
 					// palette slot is in use
-					if (pNxtPal->posInDAC >= pPrev->posInDAC + pPrev->numColours)
+					if (pNxtPal->posInDAC >= pPrev->posInDAC + pPrev->numColors)
 						// no need to move palettes down
 						break;
 
 					// move palette down - indicate change
 					pNxtPal->posInDAC = (pPrev->posInDAC
-						+ pPrev->numColours) | PALETTE_MOVED;
+						+ pPrev->numColors) | PALETTE_MOVED;
 
 					// Q the palette change in position to the video DAC
 					if (!TinselV2)
 						UpdateDACqueueHandle(pNxtPal->posInDAC,
-							pNxtPal->numColours,
+							pNxtPal->numColors,
 							pNxtPal->hPal);
 					else if (!pNxtPal->bFading)
 						UpdateDACqueue(pNxtPal->posInDAC,
-							pNxtPal->numColours,
+							pNxtPal->numColors,
 							pNxtPal->palRGB);
 
 					// update previous palette to current palette
@@ -369,7 +371,7 @@ PALQ *AllocPalette(SCNHANDLE hNewPal) {
 		}
 
 		// set new DAC index
-		iDAC = p->posInDAC + p->numColours;
+		iDAC = p->posInDAC + p->numColors;
 	}
 
 	// no free palettes
@@ -431,43 +433,43 @@ void SwapPalette(PALQ *pPalQ, SCNHANDLE hNewPal) {
 	// validate palette Q pointer
 	assert(pPalQ >= palAllocData && pPalQ <= palAllocData + NUM_PALETTES - 1);
 
-	if (pPalQ->numColours >= (int)FROM_LE_32(pNewPal->numColours)) {
+	if (pPalQ->numColors >= (int)FROM_LE_32(pNewPal->numColors)) {
 		// new palette will fit the slot
 
 		// install new palette
 		pPalQ->hPal = hNewPal;
 
 		if (TinselV2) {
-			pPalQ->numColours = FROM_LE_32(pNewPal->numColours);
+			pPalQ->numColors = FROM_LE_32(pNewPal->numColors);
 
-			// Copy all the colours
-			memcpy(pPalQ->palRGB, pNewPal->palRGB, FROM_LE_32(pNewPal->numColours) * sizeof(COLORREF));
+			// Copy all the colors
+			memcpy(pPalQ->palRGB, pNewPal->palRGB, FROM_LE_32(pNewPal->numColors) * sizeof(COLORREF));
 
 			if (!pPalQ->bFading)
 				// Q the change to the video DAC
-				UpdateDACqueue(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColours), pPalQ->palRGB);
+				UpdateDACqueue(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColors), pPalQ->palRGB);
 		} else {
 			// Q the change to the video DAC
-			UpdateDACqueueHandle(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColours), hNewPal);
+			UpdateDACqueueHandle(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColors), hNewPal);
 		}
 	} else {
-		// # colours are different - will have to update all following palette entries
+		// # colors are different - will have to update all following palette entries
 		assert(!TinselV2); // Fatal error for Tinsel 2
 
 		PALQ *pNxtPalQ;		// next palette queue position
 
 		for (pNxtPalQ = pPalQ + 1; pNxtPalQ < palAllocData + NUM_PALETTES; pNxtPalQ++) {
-			if (pNxtPalQ->posInDAC >= pPalQ->posInDAC + pPalQ->numColours)
+			if (pNxtPalQ->posInDAC >= pPalQ->posInDAC + pPalQ->numColors)
 				// no need to move palettes down
 				break;
 
 			// move palette down
 			pNxtPalQ->posInDAC = (pPalQ->posInDAC
-				+ pPalQ->numColours) | PALETTE_MOVED;
+				+ pPalQ->numColors) | PALETTE_MOVED;
 
 			// Q the palette change in position to the video DAC
 			UpdateDACqueueHandle(pNxtPalQ->posInDAC,
-				pNxtPalQ->numColours,
+				pNxtPalQ->numColors,
 				pNxtPalQ->hPal);
 
 			// update previous palette to current palette
@@ -501,12 +503,12 @@ PALQ *GetNextPalette(PALQ *pStrtPal) {
 }
 
 /**
- * Sets the current background colour.
- * @param colour			Colour to set the background to
+ * Sets the current background color.
+ * @param color			Color to set the background to
  */
-void SetBgndColour(COLORREF colour) {
-	// update background colour struct by queuing the change to the video DAC
-	UpdateDACqueue(BGND_DAC_INDEX, colour);
+void SetBgndColor(COLORREF color) {
+	// update background color struct by queuing the change to the video DAC
+	UpdateDACqueue(BGND_DAC_INDEX, color);
 }
 
 /**
@@ -544,23 +546,23 @@ void CreateTranslucentPalette(SCNHANDLE hPalette) {
 	// get a pointer to the palette
 	PALETTE *pPal = (PALETTE *)LockMem(hPalette);
 
-	// leave background colour alone
+	// leave background color alone
 	transPalette[0] = 0;
 
-	for (uint i = 0; i < FROM_LE_32(pPal->numColours); i++) {
-		// get the RGB colour model values
+	for (uint i = 0; i < FROM_LE_32(pPal->numColors); i++) {
+		// get the RGB color model values
 		uint8 red   = TINSEL_GetRValue(pPal->palRGB[i]);
 		uint8 green = TINSEL_GetGValue(pPal->palRGB[i]);
 		uint8 blue  = TINSEL_GetBValue(pPal->palRGB[i]);
 
-		// calculate the Value field of the HSV colour model
+		// calculate the Value field of the HSV color model
 		unsigned val = (red > green) ? red : green;
 		val = (val > blue) ? val : blue;
 
-		// map the Value field to one of the 4 colours reserved for the translucent palette
+		// map the Value field to one of the 4 colors reserved for the translucent palette
 		val /= 63;
 		transPalette[i + 1] = (uint8)((val == 0) ? 0 : val +
-			(TinselV2 ? TranslucentColour() : COL_HILIGHT) - 1);
+			(TinselV2 ? TranslucentColor() : COL_HILIGHT) - 1);
 	}
 }
 
@@ -572,20 +574,20 @@ void CreateGhostPalette(SCNHANDLE hPalette) {
 	PALETTE *pPal = (PALETTE *)LockMem(hPalette);
 	int i;
 
-	// leave background colour alone
+	// leave background color alone
 	ghostPalette[0] = 0;
 
-	for (i = 0; i < (int)FROM_LE_32(pPal->numColours); i++) {
-		// get the RGB colour model values
+	for (i = 0; i < (int)FROM_LE_32(pPal->numColors); i++) {
+		// get the RGB color model values
 		uint8 red   = TINSEL_GetRValue(pPal->palRGB[i]);
 		uint8 green = TINSEL_GetGValue(pPal->palRGB[i]);
 		uint8 blue  = TINSEL_GetBValue(pPal->palRGB[i]);
 
-		// calculate the Value field of the HSV colour model
+		// calculate the Value field of the HSV color model
 		unsigned val = (red > green) ? red : green;
 		val = (val > blue) ? val : blue;
 
-		// map the Value field to one of the 4 colours reserved for the translucent palette
+		// map the Value field to one of the 4 colors reserved for the translucent palette
 		val /= 64;
 		assert(/*val >= 0 &&*/ val <= 3);
 		ghostPalette[i + 1] = (uint8)(val + SysVar(ISV_GHOST_BASE));
@@ -594,25 +596,25 @@ void CreateGhostPalette(SCNHANDLE hPalette) {
 
 
 /**
- * Returns an adjusted colour RGB
- * @param colour		Colour to scale
+ * Returns an adjusted color RGB
+ * @param color		Color to scale
  */
-static COLORREF DimColour(COLORREF colour, int factor) {
+static COLORREF DimColor(COLORREF color, int factor) {
 	uint32 red, green, blue;
 
 	if (factor == 10) {
 		// No change
-		return colour;
+		return color;
 	} else if (factor == 0) {
 		// No brightness
 		return 0;
 	} else {
 		// apply multiplier to RGB components
-		red   = TINSEL_GetRValue(colour) * factor / 10;
-		green = TINSEL_GetGValue(colour) * factor / 10;
-		blue  = TINSEL_GetBValue(colour) * factor / 10;
+		red   = TINSEL_GetRValue(color) * factor / 10;
+		green = TINSEL_GetGValue(color) * factor / 10;
+		blue  = TINSEL_GetBValue(color) * factor / 10;
 
-		// return new colour
+		// return new color
 		return TINSEL_RGB(red, green, blue);
 	}
 }
@@ -620,10 +622,10 @@ static COLORREF DimColour(COLORREF colour, int factor) {
 /**
  * DimPartPalette
  */
-void DimPartPalette(SCNHANDLE hDimPal, int startColour, int length, int brightness) {
+void DimPartPalette(SCNHANDLE hDimPal, int startColor, int length, int brightness) {
 	PALQ *pPalQ;
 	PALETTE *pDimPal;
-	int iColour;
+	int iColor;
 
 	pPalQ = FindPalette(hDimPal);
 	assert(pPalQ);
@@ -631,42 +633,42 @@ void DimPartPalette(SCNHANDLE hDimPal, int startColour, int length, int brightne
 	// get pointer to dim palette
 	pDimPal = (PALETTE *)LockMem(hDimPal);
 
-	// Adjust for the fact that palettes don't contain colour 0
-	startColour -= 1;
+	// Adjust for the fact that palettes don't contain color 0
+	startColor -= 1;
 
 	// Check some other things
-	if (startColour + length > pPalQ->numColours)
-		error("DimPartPalette(): colour overrun");
+	if (startColor + length > pPalQ->numColors)
+		error("DimPartPalette(): color overrun");
 
-	for (iColour = startColour; iColour < startColour + length; iColour++) {
-		pPalQ->palRGB[iColour] = DimColour(pDimPal->palRGB[iColour], brightness);
+	for (iColor = startColor; iColor < startColor + length; iColor++) {
+		pPalQ->palRGB[iColor] = DimColor(pDimPal->palRGB[iColor], brightness);
 	}
 
 	if (!pPalQ->bFading) {
 		// Q the change to the video DAC
-		UpdateDACqueue(pPalQ->posInDAC + startColour, length, &pPalQ->palRGB[startColour]);
+		UpdateDACqueue(pPalQ->posInDAC + startColor, length, &pPalQ->palRGB[startColor]);
 	}
 }
 
-int TranslucentColour() {
+int TranslucentColor() {
 	return translucentIndex;
 }
 
-int HighlightColour() {
+int HighlightColor() {
 	UpdateDACqueue(talkIndex, (COLORREF)SysVar(SYS_HighlightRGB));
 
 	return talkIndex;
 }
 
-int TalkColour() {
+int TalkColor() {
 	return TinselV2 ? talkIndex : TALKFONT_COL;
 }
 
-void SetTalkColourRef(COLORREF colRef) {
+void SetTalkColorRef(COLORREF colRef) {
 	talkColRef = colRef;
 }
 
-COLORREF GetTalkColourRef() {
+COLORREF GetTalkColorRef() {
 	return talkColRef;
 }