MercurialMiniDisplay / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
MiniDisplay.cpp
author StephaneLenclud
Sun, 31 Aug 2014 22:57:32 +0200
changeset 18 96c013c63595
parent 17 591e9f922c63
child 19 9f659cde9ee8
permissions -rw-r--r--
Display auto detect implementation. 
     1 

     2 #include "MiniDisplay.h"

     3 #include "FutabaGP1212A01.h"

     4 #include "FutabaGP1212A02.h"

     5 

     6 

     7 MiniDisplayDevice MiniDisplayOpen(TMiniDisplayType aType, bool aAutoDetect)

     8 	{

     9 	GraphicDisplay* device=NULL;

    10 

    11 	switch (aType)

    12 		{

    13 	case EMiniDisplayAutoDetect:

    14 	case EMiniDisplayFutabaGP1212A01:

    15 		device=new GP1212A01A();

    16 		break;

    17 		

    18 	case EMiniDisplayFutabaGP1212A02:

    19 		device=new GP1212A02A();

    20 		break;

    21 

    22 	case EMiniDisplayAutoDetectFailed:

    23 		//Auto detect sequence failed

    24 		return NULL;

    25 		break;

    26 		};

    27 

    28 	int success = device->Open();

    29 	if (!success)

    30 		{

    31 		delete device;

    32 		device=NULL;

    33 		if (aAutoDetect)

    34 			{

    35 			//Go recursive for auto detect

    36 			int typeValue=(int)aType;

    37 			typeValue++;

    38 			TMiniDisplayType nextType=(TMiniDisplayType)typeValue;

    39 			return MiniDisplayOpen(nextType,aAutoDetect);

    40 			}

    41 		}

    42 

    43 	return device;

    44 	}

    45 

    46 

    47 //Open & Close functions

    48 MiniDisplayDevice MiniDisplayOpen(TMiniDisplayType aType)

    49 	{

    50 	bool autoDetect=aType==EMiniDisplayAutoDetect;

    51 	return MiniDisplayOpen(EMiniDisplayFutabaGP1212A01,autoDetect);

    52 	}

    53 

    54 

    55 

    56 

    57 //

    58 

    59 void MiniDisplayClose(MiniDisplayDevice aDevice)

    60 	{

    61 	delete ((GraphicDisplay*)aDevice);

    62 	}

    63 

    64 

    65 void MiniDisplayClear(MiniDisplayDevice aDevice)

    66 	{

    67 	if (!aDevice)

    68 		{

    69 		return;

    70 		}

    71 

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

    73 	}

    74 

    75 

    76 void MiniDisplayFill(MiniDisplayDevice aDevice)

    77 	{

    78 	if (!aDevice)

    79 		{

    80 		return;

    81 		}

    82 

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

    84 	}

    85 

    86 

    87 void MiniDisplaySwapBuffers(MiniDisplayDevice aDevice)

    88 	{

    89 	if (!aDevice)

    90 		{

    91 		return;

    92 		}

    93 

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

    95 	}

    96 

    97 //-------------------------------------------------------------

    98 int MiniDisplayMaxBrightness(MiniDisplayDevice aDevice)

    99 	{

   100 	if (!aDevice)

   101 		{

   102 		return 0;

   103 		}

   104 

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

   106 	}

   107 

   108 //-------------------------------------------------------------

   109 int MiniDisplayMinBrightness(MiniDisplayDevice aDevice)

   110 	{

   111 	if (!aDevice)

   112 		{

   113 		return 0;

   114 		}

   115 

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

   117 	}

   118 

   119 //-------------------------------------------------------------

   120 void MiniDisplaySetBrightness(MiniDisplayDevice aDevice, int aBrightness)

   121 	{

   122 	if (!aDevice)

   123 		{

   124 		return;

   125 		}

   126 

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

   128 	}

   129 

   130 //-------------------------------------------------------------

   131 int MiniDisplayWidthInPixels(MiniDisplayDevice aDevice)

   132 	{

   133 	if (!aDevice)

   134 		{

   135 		return 0;

   136 		}

   137 

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

   139 	}

   140 

   141 //-------------------------------------------------------------

   142 int MiniDisplayHeightInPixels(MiniDisplayDevice aDevice)

   143 	{

   144 	if (!aDevice)

   145 		{

   146 		return 0;

   147 		}

   148 

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

   150 	}

   151 

   152 //-------------------------------------------------------------

   153 void MiniDisplaySetPixel(MiniDisplayDevice aDevice, int aX, int aY, int aValue)

   154 	{

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

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

   157 	}

   158 

   159 //-------------------------------------------------------------

   160 wchar_t* MiniDisplayVendor(MiniDisplayDevice aDevice)

   161     {

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

   163     }

   164 

   165 //-------------------------------------------------------------

   166 wchar_t* MiniDisplayProduct(MiniDisplayDevice aDevice)

   167     {

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

   169     }

   170 

   171 //-------------------------------------------------------------

   172 wchar_t* MiniDisplaySerialNumber(MiniDisplayDevice aDevice)

   173     {

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

   175     }

   176 

   177 //-------------------------------------------------------------

   178 void MiniDisplayRequest(MiniDisplayDevice aDevice, TMiniDisplayRequest aRequest)

   179     {

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

   181     }

   182 

   183 //-------------------------------------------------------------

   184 bool MiniDisplayRequestPending(MiniDisplayDevice aDevice)

   185     {

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

   187     }

   188 

   189 //-------------------------------------------------------------

   190 TMiniDisplayRequest MiniDisplayCurrentRequest(MiniDisplayDevice aDevice)

   191     {

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

   193     }

   194 

   195 //-------------------------------------------------------------

   196 void MiniDisplayCancelRequest(MiniDisplayDevice aDevice)

   197     {

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

   199     }

   200 

   201 //-------------------------------------------------------------

   202 TMiniDisplayRequest MiniDisplayAttemptRequestCompletion(MiniDisplayDevice aDevice)

   203 	{

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

   205 	}

   206 

   207 //-------------------------------------------------------------

   208 char* MiniDisplayDeviceId(MiniDisplayDevice aDevice)

   209 	{

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

   211 	}

   212 

   213 //-------------------------------------------------------------

   214 char* MiniDisplayFirmwareRevision(MiniDisplayDevice aDevice)

   215 	{

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

   217 	}

   218 

   219 //-------------------------------------------------------------

   220 bool MiniDisplayPowerSupplyStatus(MiniDisplayDevice aDevice)

   221 	{

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

   223 	}

   224 

   225 //-------------------------------------------------------------

   226 void MiniDisplayPowerOn(MiniDisplayDevice aDevice)

   227     {

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

   229     }

   230 

   231 //-------------------------------------------------------------

   232 void MiniDisplayPowerOff(MiniDisplayDevice aDevice)

   233     {

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

   235     }

   236 

   237 //-------------------------------------------------------------

   238 bool MiniDisplaySupportPowerOnOff(MiniDisplayDevice aDevice)

   239     {

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

   241     }

   242 

   243 //-------------------------------------------------------------

   244 void MiniDisplayShowClock(MiniDisplayDevice aDevice)

   245     {

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

   247     }

   248 

   249 //-------------------------------------------------------------

   250 void MiniDisplayHideClock(MiniDisplayDevice aDevice)

   251     {

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

   253     }

   254 

   255 //-------------------------------------------------------------

   256 bool MiniDisplaySupportClock(MiniDisplayDevice aDevice)

   257     {

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

   259     }
MiniDisplay