MercurialSharpDisplayManager / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
Display.cs
author sl
Tue, 12 Aug 2014 20:37:57 +0200
changeset 17 19c1aaf900dc
parent 10 54671755add3
permissions -rw-r--r--
Adding WCF server implementation. 
     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 

     9 namespace SharpDisplayManager

    10 {

    11     class Display

    12     {

    13 

    14         //Constructor

    15         public Display()

    16         {

    17             iDevice = IntPtr.Zero;

    18         }

    19 

    20         //

    21         public bool Open()

    22         {

    23             if (iDevice == IntPtr.Zero)

    24             {

    25                 iDevice = MiniDisplayOpen();

    26             }

    27             return iDevice != IntPtr.Zero;

    28         }

    29 

    30         public void Close()

    31         {

    32             MiniDisplayClose(iDevice);

    33             iDevice = IntPtr.Zero;

    34         }

    35 

    36         public bool IsOpen()

    37         {

    38             return iDevice != IntPtr.Zero;

    39         }

    40 

    41         public void Clear()

    42         {

    43             MiniDisplayClear(iDevice);

    44         }

    45 

    46         public void Fill()

    47         {

    48             MiniDisplayFill(iDevice);

    49         }

    50 

    51         public void SwapBuffers()

    52         {

    53             MiniDisplaySwapBuffers(iDevice);

    54         }

    55 

    56         public int MaxBrightness()

    57         {

    58             return MiniDisplayMaxBrightness(iDevice);

    59         }

    60 

    61         public int MinBrightness()

    62         {

    63             return MiniDisplayMinBrightness(iDevice);

    64         }

    65 

    66         public void SetBrightness(int aBrightness)

    67         {

    68             if (!IsOpen()) return;

    69 

    70             MiniDisplaySetBrightness(iDevice, aBrightness);

    71         }

    72 

    73         public int WidthInPixels()

    74         {

    75             return MiniDisplayWidthInPixels(iDevice);

    76         }

    77 

    78         public int HeightInPixels()

    79         {

    80             return MiniDisplayHeightInPixels(iDevice);

    81         }

    82 

    83         public void SetPixel(int aX, int aY, int aValue)

    84         {

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

    86         }

    87 

    88         public void RequestPowerSupplyStatus()

    89         {

    90             MiniDisplayRequestPowerSupplyStatus(iDevice);

    91         }

    92 

    93         public void RequestDeviceId()

    94         {

    95             MiniDisplayRequestDeviceId(iDevice);

    96         }

    97 

    98         public void RequestFirmwareRevision()

    99         {

   100             MiniDisplayRequestFirmwareRevision(iDevice);

   101         }

   102 

   103         public bool PowerSupplyStatus()

   104         {

   105             bool res = MiniDisplayPowerSupplyStatus(iDevice);

   106             return res;

   107         }

   108 

   109         public TMiniDisplayRequest AttemptRequestCompletion()

   110         {

   111             return MiniDisplayAttemptRequestCompletion(iDevice);

   112         }

   113 

   114         public TMiniDisplayRequest CurrentRequest()

   115         {

   116             return MiniDisplayCurrentRequest(iDevice);

   117         }

   118 

   119         public bool IsRequestPending()

   120         {

   121             return CurrentRequest() != TMiniDisplayRequest.EMiniDisplayRequestNone;

   122         }

   123 

   124 

   125         public string Vendor()

   126         {

   127             IntPtr ptr = MiniDisplayVendor(iDevice);

   128             string str = Marshal.PtrToStringUni(ptr);

   129             return str;

   130         }

   131 

   132         public string Product()

   133         {

   134             IntPtr ptr = MiniDisplayProduct(iDevice);

   135             string str = Marshal.PtrToStringUni(ptr);

   136             return str;

   137         }

   138 

   139         public string SerialNumber()

   140         {

   141             IntPtr ptr = MiniDisplaySerialNumber(iDevice);

   142             string str = Marshal.PtrToStringUni(ptr);

   143             return str;

   144         }

   145 

   146         public string DeviceId()

   147         {

   148             IntPtr ptr = MiniDisplayDeviceId(iDevice);

   149             string str = Marshal.PtrToStringAnsi(ptr);

   150             return str;

   151         }

   152 

   153         public string FirmwareRevision()

   154         {

   155             IntPtr ptr = MiniDisplayFirmwareRevision(iDevice);

   156             string str = Marshal.PtrToStringAnsi(ptr);

   157             return str;

   158         }

   159 

   160         //Our display device handle

   161         IntPtr iDevice;

   162 

   163         public enum TMiniDisplayRequest

   164         {

   165             EMiniDisplayRequestNone,

   166             EMiniDisplayRequestDeviceId,

   167             EMiniDisplayRequestFirmwareRevision,

   168             EMiniDisplayRequestPowerSupplyStatus

   169         }

   170 

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

   172         public static extern IntPtr MiniDisplayOpen();

   173 

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

   175         public static extern void MiniDisplayClose(IntPtr aDevice);

   176 

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

   178         public static extern void MiniDisplayClear(IntPtr aDevice);

   179 

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

   181         public static extern void MiniDisplayFill(IntPtr aDevice);

   182 

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

   184         public static extern void MiniDisplaySwapBuffers(IntPtr aDevice);

   185 

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

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

   188 

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

   190         public static extern int MiniDisplayMinBrightness(IntPtr aDevice);

   191 

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

   193         public static extern int MiniDisplayMaxBrightness(IntPtr aDevice);

   194 

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

   196         public static extern int MiniDisplayWidthInPixels(IntPtr aDevice);

   197 

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

   199         public static extern int MiniDisplayHeightInPixels(IntPtr aDevice);

   200 

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

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

   203 

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

   205         public static extern IntPtr MiniDisplayVendor(IntPtr aDevice);

   206 

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

   208         public static extern IntPtr MiniDisplayProduct(IntPtr aDevice);

   209 

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

   211         public static extern IntPtr MiniDisplaySerialNumber(IntPtr aDevice);

   212 

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

   214         public static extern IntPtr MiniDisplayDeviceId(IntPtr aDevice);

   215 

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

   217         public static extern IntPtr MiniDisplayFirmwareRevision(IntPtr aDevice);

   218 

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

   220         [return: MarshalAs(UnmanagedType.I1)]

   221         public static extern bool MiniDisplayPowerSupplyStatus(IntPtr aDevice);

   222 

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

   224         public static extern void MiniDisplayRequestDeviceId(IntPtr aDevice);

   225 

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

   227         public static extern void MiniDisplayRequestFirmwareRevision(IntPtr aDevice);

   228 

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

   230         public static extern void MiniDisplayRequestPowerSupplyStatus(IntPtr aDevice);

   231 

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

   233         public static extern TMiniDisplayRequest MiniDisplayAttemptRequestCompletion(IntPtr aDevice);

   234 

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

   236         public static extern TMiniDisplayRequest MiniDisplayCurrentRequest(IntPtr aDevice);

   237 

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

   239         public static extern void MiniDisplayCancelRequest(IntPtr aDevice);

   240 

   241 

   242     }

   243 }
SharpDisplayManager