//

 // Copyright (C) 2014-2015 Stéphane Lenclud.

 //

 // This file is part of MiniDisplay.

 //

 // MiniDisplay is free software: you can redistribute it and/or modify

 // it under the terms of the GNU General Public License as published by

 // the Free Software Foundation, either version 3 of the License, or

 // (at your option) any later version.

 //

 // MiniDisplay 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 General Public License for more details.

 //

 // You should have received a copy of the GNU General Public License

 // along with MiniDisplay.  If not, see <http://www.gnu.org/licenses/>.

 //

 #include "MiniDisplay.h"

 #include "FutabaGP1212A01.h"

 #include "FutabaGP1212A02.h"

 #include "FutabaMDM166AA.h"

 /**

 Make sure you update this list when adding a new display.

 The order has to match the one from TMiniDisplayType.

 */

 wchar_t* KDisplayNames[]=

 	{

 	L"Auto-Detect",

 	L"Futaba GP1212A01",

 	L"Futaba GP1212A02",

 	L"Futaba MDM166AA",

 	L"Unknown display device"

 	};

 MiniDisplayDevice MiniDisplayOpen(TMiniDisplayType aType, bool aAutoDetect)

 	{

 	GraphicDisplay* device=NULL;

 	switch (aType)

 		{

 	case EMiniDisplayAutoDetect:

 	case EMiniDisplayFutabaGP1212A01:

 		device=new GP1212A01A();

 		break;

 	case EMiniDisplayFutabaGP1212A02:

 		device=new GP1212A02A();

 		break;

 	case EMiniDisplayFutabaMDM166AA:

 		device=new MDM166AA();

 		break;

 	case EMiniDisplayAutoDetectFailed:

 		//Auto detect sequence failed

 		return NULL;

 		break;

 		};

 	int success = device->Open();

 	if (!success)

 		{

 		delete device;

 		device=NULL;

 		if (aAutoDetect)

 			{

 			//Go recursive for auto detect

 			int typeValue=(int)aType;

 			typeValue++;

 			TMiniDisplayType nextType=(TMiniDisplayType)typeValue;

 			return MiniDisplayOpen(nextType,aAutoDetect);

 			}

 		}

 	return device;

 	}

 //Open & Close functions

 MiniDisplayDevice MiniDisplayOpen(TMiniDisplayType aType)

 	{

 	bool autoDetect=aType==EMiniDisplayAutoDetect;

 	//If we want auto detect we need to pass in our first display type

 	//If we don't want auto detect we just pass in the given display type. 

 	return MiniDisplayOpen((autoDetect?EMiniDisplayFutabaGP1212A01:aType),autoDetect);

 	}

 //

 void MiniDisplayClose(MiniDisplayDevice aDevice)

 	{

 	delete ((GraphicDisplay*)aDevice);

 	}

 int MiniDisplayTypeCount()

 	{

 	return EMiniDisplayAutoDetectFailed;

 	}

 wchar_t* MiniDisplayTypeName(TMiniDisplayType aType)

 	{

 		if (aType>=EMiniDisplayAutoDetectFailed)

 		{

 			return KDisplayNames[EMiniDisplayAutoDetectFailed];

 		}

 		return KDisplayNames[aType];

 	}

 void MiniDisplayClear(MiniDisplayDevice aDevice)

 	{

 	if (!aDevice)

 		{

 		return;

 		}

 	((GraphicDisplay*)aDevice)->Clear();

 	}

 void MiniDisplayFill(MiniDisplayDevice aDevice)

 	{

 	if (!aDevice)

 		{

 		return;

 		}

 	((GraphicDisplay*)aDevice)->Fill();

 	}

 void MiniDisplaySwapBuffers(MiniDisplayDevice aDevice)

 	{

 	if (!aDevice)

 		{

 		return;

 		}

 	((GraphicDisplay*)aDevice)->SwapBuffers();

 	}

 //-------------------------------------------------------------

 int MiniDisplayMaxBrightness(MiniDisplayDevice aDevice)

 	{

 	if (!aDevice)

 		{

 		return 0;

 		}

 	return ((GraphicDisplay*)aDevice)->MaxBrightness();

 	}

 //-------------------------------------------------------------

 int MiniDisplayMinBrightness(MiniDisplayDevice aDevice)

 	{

 	if (!aDevice)

 		{

 		return 0;

 		}

 	return ((GraphicDisplay*)aDevice)->MinBrightness();

 	}

 //-------------------------------------------------------------

 void MiniDisplaySetBrightness(MiniDisplayDevice aDevice, int aBrightness)

 	{

 	if (!aDevice)

 		{

 		return;

 		}

 	((GraphicDisplay*)aDevice)->SetBrightness(aBrightness);

 	}

 //-------------------------------------------------------------

 int MiniDisplayWidthInPixels(MiniDisplayDevice aDevice)

 	{

 	if (!aDevice)

 		{

 		return 0;

 		}

 	return ((GraphicDisplay*)aDevice)->WidthInPixels();

 	}

 //-------------------------------------------------------------

 int MiniDisplayHeightInPixels(MiniDisplayDevice aDevice)

 	{

 	if (!aDevice)

 		{

 		return 0;

 		}

 	return ((GraphicDisplay*)aDevice)->HeightInPixels();

 	}

 //-------------------------------------------------------------

 void MiniDisplaySetPixel(MiniDisplayDevice aDevice, int aX, int aY, unsigned int aPixel)

 	{

 	//aValue&=0x00FFFFFF; //Filter out alpha component

 	return ((GraphicDisplay*)aDevice)->SetPixel(aX,aY,aPixel);

 	}

 //-------------------------------------------------------------

 wchar_t* MiniDisplayVendor(MiniDisplayDevice aDevice)

     {

     return ((GraphicDisplay*)aDevice)->Vendor();

     }

 //-------------------------------------------------------------

 wchar_t* MiniDisplayProduct(MiniDisplayDevice aDevice)

     {

     return ((GraphicDisplay*)aDevice)->Product();

     }

 //-------------------------------------------------------------

 wchar_t* MiniDisplaySerialNumber(MiniDisplayDevice aDevice)

     {

     return ((GraphicDisplay*)aDevice)->SerialNumber();

     }

 //-------------------------------------------------------------

 void MiniDisplayRequest(MiniDisplayDevice aDevice, TMiniDisplayRequest aRequest)

     {

     ((GraphicDisplay*)aDevice)->Request(aRequest);

     }

 //-------------------------------------------------------------

 bool MiniDisplayRequestPending(MiniDisplayDevice aDevice)

     {

     return ((GraphicDisplay*)aDevice)->RequestPending();

     }

 //-------------------------------------------------------------

 TMiniDisplayRequest MiniDisplayCurrentRequest(MiniDisplayDevice aDevice)

     {

     return ((GraphicDisplay*)aDevice)->CurrentRequest();

     }

 //-------------------------------------------------------------

 void MiniDisplayCancelRequest(MiniDisplayDevice aDevice)

     {

     ((GraphicDisplay*)aDevice)->CancelRequest();

     }

 //-------------------------------------------------------------

 TMiniDisplayRequest MiniDisplayAttemptRequestCompletion(MiniDisplayDevice aDevice)

 	{

 	return ((GraphicDisplay*)aDevice)->AttemptRequestCompletion();

 	}

 //-------------------------------------------------------------

 char* MiniDisplayDeviceId(MiniDisplayDevice aDevice)

 	{

 	return ((GraphicDisplay*)aDevice)->DeviceId();

 	}

 //-------------------------------------------------------------

 char* MiniDisplayFirmwareRevision(MiniDisplayDevice aDevice)

 	{

 	return ((GraphicDisplay*)aDevice)->FirmwareRevision();

 	}

 //-------------------------------------------------------------

 bool MiniDisplayPowerSupplyStatus(MiniDisplayDevice aDevice)

 	{

 	return ((GraphicDisplay*)aDevice)->IsPowerOn();

 	}

 //-------------------------------------------------------------

 void MiniDisplayPowerOn(MiniDisplayDevice aDevice)

     {

     ((GraphicDisplay*)aDevice)->TurnPowerOn();

     }

 //-------------------------------------------------------------

 void MiniDisplayPowerOff(MiniDisplayDevice aDevice)

     {

     ((GraphicDisplay*)aDevice)->TurnPowerOff();

     }

 //-------------------------------------------------------------

 bool MiniDisplaySupportPowerOnOff(MiniDisplayDevice aDevice)

     {

     return ((GraphicDisplay*)aDevice)->SupportPowerOnOff();

     }

 //-------------------------------------------------------------

 void MiniDisplayShowClock(MiniDisplayDevice aDevice)

     {

     ((GraphicDisplay*)aDevice)->ShowClock();

     }

 //-------------------------------------------------------------

 void MiniDisplayHideClock(MiniDisplayDevice aDevice)

     {

     ((GraphicDisplay*)aDevice)->HideClock();

     }

 //-------------------------------------------------------------

 bool MiniDisplaySupportClock(MiniDisplayDevice aDevice)

     {

     return ((GraphicDisplay*)aDevice)->SupportClock();

     }

 //-------------------------------------------------------------

 int MiniDisplayIconCount(MiniDisplayDevice aDevice, TMiniDisplayIconType aIcon)

 	{

 	return ((GraphicDisplay*)aDevice)->IconCount(aIcon);

 	}

 //-------------------------------------------------------------

 int MiniDisplayIconStatusCount(MiniDisplayDevice aDevice, TMiniDisplayIconType aIcon)

 	{

 	return ((GraphicDisplay*)aDevice)->IconStatusCount(aIcon);

 	}

 //-------------------------------------------------------------

 void MiniDisplaySetIconStatus(MiniDisplayDevice aDevice, TMiniDisplayIconType aIcon, int aIndex, int aStatus)

 	{

 	((GraphicDisplay*)aDevice)->SetIconStatus(aIcon,aIndex,aStatus);

 	}