// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <gdi.h>

#include "GDIPANIC.h"

//

// CPalette

//

_LIT(KGdiCPalettePanicCategory,"CPalette");

EXPORT_C CPalette::CPalette():

	CBase(),

	iArray(NULL),

	iNumEntries(0)

	{}

EXPORT_C CPalette::~CPalette()

/** Destructor. */

	{

	delete [] iArray;

	}

EXPORT_C void CPalette::Clear()

/** Clears all the entries in the palette to TRgb(0). */

	{

	TRgb blank(0);

	for(TInt count=0;count<iNumEntries;count++)

		iArray[count]=blank;

	}

EXPORT_C CPalette* CPalette::NewL(TInt aNumberOfEntries)

/** Creates a new palette with the specified number of entries. 

@param aNumberOfEntries The number of entries in the palette being created.

@return The newly created palette. */

	{

	CPalette* thisptr=new(ELeave) CPalette;

	CleanupStack::PushL(thisptr);

	thisptr->ConstructL(aNumberOfEntries);

	CleanupStack::Pop();

	return(thisptr);

	}

EXPORT_C CPalette* CPalette::NewDefaultL(TDisplayMode aDispMode)

/** Creates a new default palette for the specified display mode. The default palette 

for a particular display mode has one entry for each possible colour in that 

display mode (2 entries for EGray2, 16 entries for EColor16 etc.); the colour 

of each index p in the default palette is set to its default value according 

to its display mode (e.g. if the mode is EColor16 then palette[p]==TRgb::Color16(p); 

if the mode is EGray4 then palette[p]==TRgb::_Gray4(p)). 

@param aDispMode The display mode for which the palette is to be created. 

@return The newly created palette */

	{

	TInt numentries=0;

	switch(aDispMode)

		{

	case EGray2:

		numentries=2;

		break;

	case EGray4:

		numentries=4;

		break;

	case EGray16:

	case EColor16:

		numentries=16;

		break;

	case EGray256:

	case EColor256:

		numentries=256;

		break;

	default:

		User::Leave(KErrNotSupported);

		};

	CPalette* thisptr=new(ELeave) CPalette;

	CleanupStack::PushL(thisptr);

	thisptr->ConstructL(numentries);

	TInt count=0;

	switch(aDispMode)

		{

	case EGray2:

		thisptr->iArray[0]=TRgb::_Gray2(0);

		thisptr->iArray[1]=TRgb::_Gray2(1);

		break;

	case EGray4:

		for(;count<numentries;count++)

			thisptr->iArray[count]=TRgb::_Gray4(count);

		break;

	case EGray16:

		for(;count<numentries;count++)

			thisptr->iArray[count]=TRgb::_Gray16(count);

		break;

	case EColor16:

		for(;count<numentries;count++)

			thisptr->iArray[count]=TRgb::Color16(count);

		break;

	case EGray256:

		for(;count<numentries;count++)

			thisptr->iArray[count]=TRgb::_Gray256(count);

		break;

	case EColor256:

		for(;count<numentries;count++)

			thisptr->iArray[count]=TRgb::Color256(count);

		break;

	default:

		User::Leave(KErrNotSupported);

		}

	CleanupStack::Pop();

	return(thisptr);

	}

void CPalette::ConstructL(TInt aNumberOfEntries)

	{

	if(aNumberOfEntries<=0) User::Leave(KErrArgument);

	iArray=new(ELeave) TRgb[aNumberOfEntries];

	iNumEntries=aNumberOfEntries;

	}

EXPORT_C TRgb CPalette::GetEntry(TInt aIndex) const

/** Gets the RGB value of the palette entry at aPaletteIndex.

@param aPaletteIndex The index of the palette entry to get. 

@return The RGB value of the palette entry */

	{

	GDI_ASSERT_ALWAYS_GENERAL(aIndex<iNumEntries,User::Panic(KGdiCPalettePanicCategory,KErrTooBig));

	if(aIndex<iNumEntries)

		return(iArray[aIndex]);

	TRgb defaultcol(0,0,0);

	return(defaultcol);

	}

EXPORT_C TRgb CPalette::NearestEntry(const TRgb& aColor) const

/** Gets the colour in the palette which is closest to the specified colour.

@param aColor The colour to find.

@return The colour in the palette which is closest to the specified colour. */

	{

	return(iArray[NearestIndex(aColor)]);

	}

EXPORT_C TInt CPalette::NearestIndex(const TRgb& aColor) const

/** Gets the index of the colour in the palette which is closest to the specified 

colour.

@param aColor The colour to find.

@return The index of the colour in the palette which is closest to the specified 

colour. */

	{

	TRgb* entry = iArray;

	TRgb* entryLimit = entry+iNumEntries;

	TRgb* lowest = entry;

	TInt mindif = KMaxTInt;

	while(entry<entryLimit)

		{

		TInt value = entry->Internal();

		TInt difference = Abs((TInt)(aColor.Internal()&0xFF)-(TInt)(value&0xFF))+

						  (Abs((TInt)(aColor.Internal()&0xFF00)-(TInt)(value&0xFF00))>>8)+

						  (Abs((TInt)(aColor.Internal()&0xFF0000)-(TInt)(value&0xFF0000))>>16);

		if(difference<mindif)

			{

			lowest=entry;

			mindif=difference;

			if(difference==0)

				break;

			}

		entry++;

		}

	return(lowest-iArray);

	}

EXPORT_C void CPalette::SetEntry(TInt aIndex,const TRgb& aColor)

/** Sets the palette entry at aPaletteIndex to the RGB value aPaletteEntry.

@param aPaletteIndex The index of the palette entry to be set.

@param aPaletteEntry The RGB value to set that entry to. */

	{

	GDI_ASSERT_ALWAYS_GENERAL(aIndex<iNumEntries,User::Panic(KGdiCPalettePanicCategory,KErrTooBig));

	iArray[aIndex]=aColor;

	}

EXPORT_C void CPalette::GetDataPtr(TInt aFirstColor,TInt aNumColors,TPtr8& aPtr)

/** Returns a descriptor over the palette entries for the specifed colors. It is 

designed so that the descriptor can be passed to another thread and that thread 

copy the relevant entries.

@param aFirstColor The first colour.

@param aNumColors Number of colours.

@param aPtr Descriptor. */

	{

	TInt size=sizeof(TRgb)*aNumColors;

	aPtr.Set(REINTERPRET_CAST(TUint8*,&iArray[aFirstColor]),size,size);

	}