MercurialSharpDisplayManager / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
Server/Display.cs
author StephaneLenclud
Thu, 05 Feb 2015 17:04:59 +0100
changeset 106 32270ff62819
parent 104 189aac7dd3d6
child 108 7dd1d881c142
permissions -rw-r--r--
Server: Adding scrolling speed setting.
Fixing issue with alignment of newly created text field not being set properly.
Client: Now starting-up first client automatically in debug mode. 
     1 using System;

     2 using System.Collections.Generic;

     3 using System.Linq;

     4 using System.Text;

     5 using System.Threading.Tasks;

     6 //

     7 using System.Runtime.InteropServices;

     8 //using System.Runtime.Serialization;

     9 

    10 namespace SharpDisplayManager

    11 {

    12 

    13 

    14     /// <summary>

    15     /// Provide access to our display hardware through MiniDisplay API.

    16     /// </summary>

    17     public class Display

    18     {

    19 		public delegate void OnOpenedHandler(Display aDisplay);

    20 		public event OnOpenedHandler OnOpened;

    21 

    22 		public delegate void OnClosedHandler(Display aDisplay);

    23 		public event OnClosedHandler OnClosed;

    24 

    25 		//Our display device handle

    26 		IntPtr iDevice;

    27 

    28 		//static functions

    29 		public static int TypeCount()

    30 		{

    31 			return MiniDisplayTypeCount();

    32 		}

    33 

    34 		public static string TypeName(TMiniDisplayType aType)

    35 		{

    36 			IntPtr ptr = MiniDisplayTypeName(aType);

    37 			string str = Marshal.PtrToStringUni(ptr);

    38 			return str;

    39 		}

    40 

    41         //Constructor

    42         public Display()

    43         {

    44             iDevice = IntPtr.Zero;

    45         }

    46 

    47         //

    48         public bool Open(TMiniDisplayType aType)

    49         {

    50 			if (IsOpen())

    51 			{

    52 				//Already open return an error

    53 				return false;

    54 			}

    55 

    56             iDevice = MiniDisplayOpen(aType);

    57 

    58             bool success = iDevice != IntPtr.Zero;

    59 			if (success)

    60 			{

    61 				//Broadcast opened event

    62 				OnOpened(this);

    63 			}

    64 

    65 			return success;

    66         }

    67 

    68         public void Close()

    69         {

    70 			if (!IsOpen())

    71 			{

    72 				//Pointless

    73 				return;

    74 			}

    75 

    76 			//Controversially clearing our screen before closing

    77 			//Consider moving this up into the UI layer

    78 			Clear(); 

    79 			SwapBuffers();

    80 			//

    81             MiniDisplayClose(iDevice);

    82             iDevice = IntPtr.Zero;

    83 			//Broadcast closed event

    84 			OnClosed(this);

    85         }

    86 

    87         public bool IsOpen()

    88         {

    89             return iDevice != IntPtr.Zero;

    90         }

    91 

    92         public void Clear()

    93         {

    94             MiniDisplayClear(iDevice);

    95         }

    96 

    97         public void Fill()

    98         {

    99             MiniDisplayFill(iDevice);

   100         }

   101 

   102         public void SwapBuffers()

   103         {

   104             MiniDisplaySwapBuffers(iDevice);

   105         }

   106 

   107         public int MaxBrightness()

   108         {

   109             return MiniDisplayMaxBrightness(iDevice);

   110         }

   111 

   112         public int MinBrightness()

   113         {

   114             return MiniDisplayMinBrightness(iDevice);

   115         }

   116 

   117         public void SetBrightness(int aBrightness)

   118         {

   119             if (!IsOpen()) return;

   120 

   121             MiniDisplaySetBrightness(iDevice, aBrightness);

   122         }

   123 

   124         public int WidthInPixels()

   125         {

   126             return MiniDisplayWidthInPixels(iDevice);

   127         }

   128 

   129         public int HeightInPixels()

   130         {

   131             return MiniDisplayHeightInPixels(iDevice);

   132         }

   133 

   134         public void SetPixel(int aX, int aY, uint aValue)

   135         {

   136             MiniDisplaySetPixel(iDevice,aX,aY,aValue);

   137         }

   138 

   139         public void RequestPowerSupplyStatus()

   140         {

   141             MiniDisplayRequest(iDevice, TMiniDisplayRequest.EMiniDisplayRequestPowerSupplyStatus);

   142         }

   143 

   144         public void RequestDeviceId()

   145         {

   146             MiniDisplayRequest(iDevice, TMiniDisplayRequest.EMiniDisplayRequestDeviceId);

   147         }

   148 

   149         public void RequestFirmwareRevision()

   150         {

   151             MiniDisplayRequest(iDevice, TMiniDisplayRequest.EMiniDisplayRequestFirmwareRevision);

   152         }

   153 

   154         public void PowerOn()

   155         {

   156             MiniDisplayPowerOn(iDevice);

   157         }

   158 

   159         public void PowerOff()

   160         {

   161             MiniDisplayPowerOff(iDevice);

   162         }

   163 

   164         public bool SupportPowerOnOff()

   165         {

   166             return MiniDisplaySupportPowerOnOff(iDevice);

   167         }

   168 

   169         public void ShowClock()

   170         {

   171             MiniDisplayShowClock(iDevice);

   172         }

   173 

   174         public void HideClock()

   175         {

   176             MiniDisplayHideClock(iDevice);

   177         }

   178 

   179         public bool SupportClock()

   180         {

   181             return MiniDisplaySupportClock(iDevice);

   182         }

   183 

   184         public bool PowerSupplyStatus()

   185         {

   186             bool res = MiniDisplayPowerSupplyStatus(iDevice);

   187             return res;

   188         }

   189 

   190         public TMiniDisplayRequest AttemptRequestCompletion()

   191         {

   192             return MiniDisplayAttemptRequestCompletion(iDevice);

   193         }

   194 

   195         public TMiniDisplayRequest CurrentRequest()

   196         {

   197             return MiniDisplayCurrentRequest(iDevice);

   198         }

   199 

   200         public bool IsRequestPending()

   201         {

   202             return CurrentRequest() != TMiniDisplayRequest.EMiniDisplayRequestNone;

   203         }

   204 

   205 

   206         public string Vendor()

   207         {

   208             IntPtr ptr = MiniDisplayVendor(iDevice);

   209             string str = Marshal.PtrToStringUni(ptr);

   210             return str;

   211         }

   212 

   213         public string Product()

   214         {

   215             IntPtr ptr = MiniDisplayProduct(iDevice);

   216             string str = Marshal.PtrToStringUni(ptr);

   217             return str;

   218         }

   219 

   220         public string SerialNumber()

   221         {

   222             IntPtr ptr = MiniDisplaySerialNumber(iDevice);

   223             string str = Marshal.PtrToStringUni(ptr);

   224             return str;

   225         }

   226 

   227         public string DeviceId()

   228         {

   229             IntPtr ptr = MiniDisplayDeviceId(iDevice);

   230             string str = Marshal.PtrToStringAnsi(ptr);

   231             return str;

   232         }

   233 

   234         public string FirmwareRevision()

   235         {

   236             IntPtr ptr = MiniDisplayFirmwareRevision(iDevice);

   237             string str = Marshal.PtrToStringAnsi(ptr);

   238             return str;

   239         }

   240 

   241         //[Serializable]

   242         public enum TMiniDisplayType

   243         {

   244             EMiniDisplayAutoDetect, /*Not yet implemented*/

   245             //[EnumMember(Value = "EMiniDisplayFutabaGP1212A01")]

   246             EMiniDisplayFutabaGP1212A01,

   247             //[EnumMember(Value = "EMiniDisplayFutabaGP1212A01")]

   248             EMiniDisplayFutabaGP1212A02

   249         };

   250 

   251 

   252         public enum TMiniDisplayRequest

   253         {

   254             EMiniDisplayRequestNone,

   255             EMiniDisplayRequestDeviceId,

   256             EMiniDisplayRequestFirmwareRevision,

   257             EMiniDisplayRequestPowerSupplyStatus

   258         };

   259 

   260         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   261         public static extern IntPtr MiniDisplayOpen(TMiniDisplayType aType);

   262 

   263         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   264         public static extern void MiniDisplayClose(IntPtr aDevice);

   265 

   266 		[DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   267 		public static extern int MiniDisplayTypeCount();

   268 

   269 		[DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   270 		public static extern IntPtr MiniDisplayTypeName(TMiniDisplayType aType);

   271 

   272         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   273         public static extern void MiniDisplayClear(IntPtr aDevice);

   274 

   275         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   276         public static extern void MiniDisplayFill(IntPtr aDevice);

   277 

   278         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   279         public static extern void MiniDisplaySwapBuffers(IntPtr aDevice);

   280 

   281         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   282         public static extern void MiniDisplaySetBrightness(IntPtr aDevice, int aBrightness);

   283 

   284         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   285         public static extern int MiniDisplayMinBrightness(IntPtr aDevice);

   286 

   287         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   288         public static extern int MiniDisplayMaxBrightness(IntPtr aDevice);

   289 

   290         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   291         public static extern int MiniDisplayWidthInPixels(IntPtr aDevice);

   292 

   293         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   294         public static extern int MiniDisplayHeightInPixels(IntPtr aDevice);

   295 

   296         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   297         public static extern int MiniDisplaySetPixel(IntPtr aDevice, int aX, int aY, uint aValue);

   298 

   299         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   300         public static extern IntPtr MiniDisplayVendor(IntPtr aDevice);

   301 

   302         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   303         public static extern IntPtr MiniDisplayProduct(IntPtr aDevice);

   304 

   305         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   306         public static extern IntPtr MiniDisplaySerialNumber(IntPtr aDevice);

   307 

   308         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   309         public static extern IntPtr MiniDisplayDeviceId(IntPtr aDevice);

   310 

   311         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   312         public static extern IntPtr MiniDisplayFirmwareRevision(IntPtr aDevice);

   313 

   314         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   315         [return: MarshalAs(UnmanagedType.I1)]

   316         public static extern bool MiniDisplayPowerSupplyStatus(IntPtr aDevice);

   317 

   318         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   319         public static extern void MiniDisplayRequest(IntPtr aDevice, TMiniDisplayRequest aRequest);

   320 

   321         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   322         public static extern TMiniDisplayRequest MiniDisplayAttemptRequestCompletion(IntPtr aDevice);

   323 

   324         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   325         public static extern TMiniDisplayRequest MiniDisplayCurrentRequest(IntPtr aDevice);

   326 

   327         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   328         public static extern void MiniDisplayCancelRequest(IntPtr aDevice);

   329 

   330         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   331         public static extern void MiniDisplayPowerOn(IntPtr aDevice);

   332 

   333         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   334         public static extern void MiniDisplayPowerOff(IntPtr aDevice);

   335 

   336         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   337         [return: MarshalAs(UnmanagedType.I1)]

   338         public static extern bool MiniDisplaySupportPowerOnOff(IntPtr aDevice);

   339 

   340         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   341         public static extern void MiniDisplayShowClock(IntPtr aDevice);

   342 

   343         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   344         public static extern void MiniDisplayHideClock(IntPtr aDevice);

   345 

   346         [DllImport("MiniDisplay.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

   347         [return: MarshalAs(UnmanagedType.I1)]

   348         public static extern bool MiniDisplaySupportClock(IntPtr aDevice);

   349 

   350 

   351     }

   352 }
SharpDisplayManager