MercurialMiniDisplay / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
MiniDisplay.cpp
author sl
Sun, 31 Aug 2014 21:35:36 +0200
changeset 17 591e9f922c63
parent 16 42ba42be810d
child 18 96c013c63595
permissions -rw-r--r--
GP1212A02: Clock support. 
     1 

     2 #include "MiniDisplay.h"

     3 #include "FutabaGP1212A01.h"

     4 #include "FutabaGP1212A02.h"

     5 

     6 

     7 

     8 //Open & Close functions

     9 MiniDisplayDevice MiniDisplayOpen(TMiniDisplayType aType)

    10 	{

    11 	GraphicDisplay* device=NULL;

    12 

    13 	switch (aType)

    14 		{

    15 	case EMiniDisplayAutoDetect:

    16 		//TODO

    17 		device=new GP1212A01A();

    18 		break;

    19 

    20 	case EMiniDisplayFutabaGP1212A01:

    21 		device=new GP1212A01A();

    22 		break;

    23 		

    24 	case EMiniDisplayFutabaGP1212A02:

    25 		device=new GP1212A02A();

    26 		break;

    27 		};

    28 

    29 	int success = device->Open();

    30 	if (!success)

    31 		{

    32 		delete device;

    33 		device=NULL;

    34 		}

    35 

    36 	return device;

    37 	}

    38 

    39 //

    40 

    41 void MiniDisplayClose(MiniDisplayDevice aDevice)

    42 	{

    43 	delete ((GraphicDisplay*)aDevice);

    44 	}

    45 

    46 

    47 void MiniDisplayClear(MiniDisplayDevice aDevice)

    48 	{

    49 	if (!aDevice)

    50 		{

    51 		return;

    52 		}

    53 

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

    55 	}

    56 

    57 

    58 void MiniDisplayFill(MiniDisplayDevice aDevice)

    59 	{

    60 	if (!aDevice)

    61 		{

    62 		return;

    63 		}

    64 

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

    66 	}

    67 

    68 

    69 void MiniDisplaySwapBuffers(MiniDisplayDevice aDevice)

    70 	{

    71 	if (!aDevice)

    72 		{

    73 		return;

    74 		}

    75 

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

    77 	}

    78 

    79 //-------------------------------------------------------------

    80 int MiniDisplayMaxBrightness(MiniDisplayDevice aDevice)

    81 	{

    82 	if (!aDevice)

    83 		{

    84 		return 0;

    85 		}

    86 

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

    88 	}

    89 

    90 //-------------------------------------------------------------

    91 int MiniDisplayMinBrightness(MiniDisplayDevice aDevice)

    92 	{

    93 	if (!aDevice)

    94 		{

    95 		return 0;

    96 		}

    97 

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

    99 	}

   100 

   101 //-------------------------------------------------------------

   102 void MiniDisplaySetBrightness(MiniDisplayDevice aDevice, int aBrightness)

   103 	{

   104 	if (!aDevice)

   105 		{

   106 		return;

   107 		}

   108 

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

   110 	}

   111 

   112 //-------------------------------------------------------------

   113 int MiniDisplayWidthInPixels(MiniDisplayDevice aDevice)

   114 	{

   115 	if (!aDevice)

   116 		{

   117 		return 0;

   118 		}

   119 

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

   121 	}

   122 

   123 //-------------------------------------------------------------

   124 int MiniDisplayHeightInPixels(MiniDisplayDevice aDevice)

   125 	{

   126 	if (!aDevice)

   127 		{

   128 		return 0;

   129 		}

   130 

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

   132 	}

   133 

   134 //-------------------------------------------------------------

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

   136 	{

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

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

   139 	}

   140 

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

   142 wchar_t* MiniDisplayVendor(MiniDisplayDevice aDevice)

   143     {

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

   145     }

   146 

   147 //-------------------------------------------------------------

   148 wchar_t* MiniDisplayProduct(MiniDisplayDevice aDevice)

   149     {

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

   151     }

   152 

   153 //-------------------------------------------------------------

   154 wchar_t* MiniDisplaySerialNumber(MiniDisplayDevice aDevice)

   155     {

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

   157     }

   158 

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

   160 void MiniDisplayRequest(MiniDisplayDevice aDevice, TMiniDisplayRequest aRequest)

   161     {

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

   163     }

   164 

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

   166 bool MiniDisplayRequestPending(MiniDisplayDevice aDevice)

   167     {

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

   169     }

   170 

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

   172 TMiniDisplayRequest MiniDisplayCurrentRequest(MiniDisplayDevice aDevice)

   173     {

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

   175     }

   176 

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

   178 void MiniDisplayCancelRequest(MiniDisplayDevice aDevice)

   179     {

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

   181     }

   182 

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

   184 TMiniDisplayRequest MiniDisplayAttemptRequestCompletion(MiniDisplayDevice aDevice)

   185 	{

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

   187 	}

   188 

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

   190 char* MiniDisplayDeviceId(MiniDisplayDevice aDevice)

   191 	{

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

   193 	}

   194 

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

   196 char* MiniDisplayFirmwareRevision(MiniDisplayDevice aDevice)

   197 	{

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

   199 	}

   200 

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

   202 bool MiniDisplayPowerSupplyStatus(MiniDisplayDevice aDevice)

   203 	{

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

   205 	}

   206 

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

   208 void MiniDisplayPowerOn(MiniDisplayDevice aDevice)

   209     {

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

   211     }

   212 

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

   214 void MiniDisplayPowerOff(MiniDisplayDevice aDevice)

   215     {

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

   217     }

   218 

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

   220 bool MiniDisplaySupportPowerOnOff(MiniDisplayDevice aDevice)

   221     {

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

   223     }

   224 

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

   226 void MiniDisplayShowClock(MiniDisplayDevice aDevice)

   227     {

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

   229     }

   230 

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

   232 void MiniDisplayHideClock(MiniDisplayDevice aDevice)

   233     {

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

   235     }

   236 

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

   238 bool MiniDisplaySupportClock(MiniDisplayDevice aDevice)

   239     {

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

   241     }
MiniDisplay