Wrapping DeviceIoControl () for IOCTL_VIDEO_QUE RY_DISPLAY_BRIG HTNES

[ewoo]

I'm trying to write a wrapper in csharp to wrap DeviceIoControl () win32
method for IOCTL_VIDEO_QUE RY_DISPLAY_BRIG HTNESS control code--without much
luck.

I've seen lots of examples out there for low-level file access but can't
seem to any for the display. Can you provide some samples of how I might do
this?

Below is my code thus far...

using System;
using System.Diagnost ics;
using System.Runtime. InteropServices ;

namespace PowerManagement Test
{
[StructLayout(La youtKind.Sequen tial)]
internal struct DISPLAY_BRIGHTN ESS
{
public byte DisplayPolicy; // 0x00000001 Value can be DISPLAYPOLICY_A C or
DISPLAYPOLICY_D C or DISPLAYPOLICY_B OTH
public byte ACBrightness; // 0x00000002
public byte DCBrightness; // 0x00000001 | 0x00000002
}

/// <summary>
/// Constants lifted from winioctl.h from Platform SDK.
/// </summary>
internal class WinIoCtlConstan ts
{
const uint FILE_DEVICE_FIL E_SYSTEM = 0x00000009;
const uint FILE_DEVICE_VID EO = 0x00000023;

const uint FILE_ANY_ACCESS = 0;
const uint FILE_SPECIAL_AC CESS = FILE_ANY_ACCESS ;

const uint METHOD_BUFFERED = 0;
const uint METHOD_NEITHER = 3;

public static uint FSCTL_GET_VOLUM E_BITMAP =
CTL_CODE(FILE_D EVICE_FILE_SYST EM, 27, METHOD_NEITHER, FILE_ANY_ACCESS );
public static uint FSCTL_GET_RETRI EVAL_POINTERS =
CTL_CODE(FILE_D EVICE_FILE_SYST EM, 28, METHOD_NEITHER, FILE_ANY_ACCESS );
public static uint FSCTL_MOVE_FILE = CTL_CODE(FILE_D EVICE_FILE_SYST EM, 29,
METHOD_BUFFERED , FILE_SPECIAL_AC CESS);

public static uint IOCTL_VIDEO_QUE RY_SUPPORTED_BR IGHTNESS =
CTL_CODE(FILE_D EVICE_VIDEO, 293, METHOD_BUFFERED , FILE_ANY_ACCESS );
public static uint IOCTL_VIDEO_QUE RY_DISPLAY_BRIG HTNESS =
CTL_CODE(FILE_D EVICE_VIDEO, 294, METHOD_BUFFERED , FILE_ANY_ACCESS );
public static uint IOCTL_VIDEO_SET _DISPLAY_BRIGHT NESS =
CTL_CODE(FILE_D EVICE_VIDEO, 295, METHOD_BUFFERED , FILE_ANY_ACCESS );

static uint CTL_CODE(uint DeviceType, uint Function, uint Method, uint
Access)
{
return ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) |
(Method);
}
}

class WinIoCtl
{
// Constants.
const uint FILE_SHARE_READ = 0x00000001;
const uint FILE_SHARE_WRIT E = 0x00000002;
const uint FILE_SHARE_DELE TE = 0x00000004;
const uint OPEN_EXISTING = 3;

const uint GENERIC_READ = (0x80000000);
const uint GENERIC_WRITE = (0x40000000);

const uint FILE_FLAG_NO_BU FFERING = 0x20000000;
const uint FILE_READ_ATTRI BUTES = (0x0080);
const uint FILE_WRITE_ATTR IBUTES = 0x0100;
const uint ERROR_INSUFFICI ENT_BUFFER = 122;

[DllImport("kern el32.dll", SetLastError = true)]
static extern bool DeviceIoControl (
IntPtr hDevice,
uint dwIoControlCode ,
IntPtr lpInBuffer,
uint nInBufferSize,
[Out] IntPtr lpOutBuffer,
uint nOutBufferSize,
ref uint lpBytesReturned ,
IntPtr lpOverlapped);

[DllImport("kern el32.dll", SetLastError = true)]
static extern IntPtr CreateFile(
string lpFileName,
uint dwDesiredAccess ,
uint dwShareMode,
IntPtr lpSecurityAttri butes,
uint dwCreationDispo sition,
uint dwFlagsAndAttri butes,
IntPtr hTemplateFile);

[DllImport("kern el32.dll", SetLastError = true)]
static extern int CloseHandle(Int Ptr hObject);

static private IntPtr OpenVolume(stri ng DeviceName)
{
IntPtr hDevice;
hDevice = CreateFile(
@"\\.\" + DeviceName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRIT E,
IntPtr.Zero,
OPEN_EXISTING,
0,
IntPtr.Zero);
if ((int)hDevice == -1)
{
throw new Exception(Marsh al.GetLastWin32 Error().ToStrin g());
}
return hDevice;
}
static private IntPtr OpenFile(string path)
{
IntPtr hFile;
hFile = CreateFile(
path,
FILE_READ_ATTRI BUTES | FILE_WRITE_ATTR IBUTES,
FILE_SHARE_READ | FILE_SHARE_WRIT E,
IntPtr.Zero,
OPEN_EXISTING,
0,
IntPtr.Zero);
if ((int)hFile == -1)
{
throw new Exception(Marsh al.GetLastWin32 Error().ToStrin g());
}
return hFile;
}

static private IntPtr OpenLcdDevice()
{
IntPtr hDevice;
hDevice = CreateFile(
@"\\.\LCD",
GENERIC_READ,
FILE_SHARE_READ ,
IntPtr.Zero,
OPEN_EXISTING,
0,
IntPtr.Zero);
if ((int)hDevice == -1)
{
Debug.WriteLine ("OpenLCD Win32 Error: " +
Marshal.GetLast Win32Error().To String());
throw new Exception(Marsh al.GetLastWin32 Error().ToStrin g());
}
return hDevice;
}

static public void QueryDisplayBri ghtness()
{
IntPtr hDevice = IntPtr.Zero;

// Allocate memory for the Display Brightness structure.
Type structType = typeof(DISPLAY_ BRIGHTNESS);
int structSize = Marshal.SizeOf( structType);
IntPtr pDisplayBrightn ess = Marshal.AllocHG lobal(structSiz e);

DISPLAY_BRIGHTN ESS brightness;
brightness =
(DISPLAY_BRIGHT NESS)Marshal.Pt rToStructure((I ntPtr)pDisplayB rightness,
structType);
// brightness.Disp layPolicy = Convert.ToByte( 1);

try
{
hDevice = OpenLcdDevice() ;

Int64 i64 = 0;

uint outputBufferSiz e = Convert.ToUInt3 2(structSize);
uint bytesReturned = 0;

bool fResult = DeviceIoControl (
hDevice,
WinIoCtlConstan ts.IOCTL_VIDEO_ QUERY_DISPLAY_B RIGHTNESS,
IntPtr.Zero, // Set to NULL.
(uint)Marshal.S izeOf(i64), // Set to zero.
pDisplayBrightn ess, // Pointer to a buffer that receives the
DISPLAY_BRIGHTN ESS structure.
outputBufferSiz e,
ref bytesReturned,
IntPtr.Zero);

Debug.WriteLine ("Bytes returned: " + bytesReturned.T oString());

if (!fResult)
{
Debug.WriteLine ("WIN32 Error: " +
Marshal.GetLast Win32Error().To String(), "QueryDisplayBr ightness");
throw new Exception(Marsh al.GetLastWin32 Error().ToStrin g());
}

int resultAddress = (int)pDisplayBr ightness;
brightness =
(DISPLAY_BRIGHT NESS)Marshal.Pt rToStructure((I ntPtr)resultAdd ress, structType);

Debug.WriteLine ("AC Brightness: " + brightness.ACBr ightness.ToStri ng());
Debug.WriteLine ("DC Brightness: " + brightness.DCBr ightness.ToStri ng());

}
catch(Exception ex)
{
Debug.WriteLine (ex.ToString()) ;
}
finally
{
CloseHandle(hDe vice);
hDevice = IntPtr.Zero;

Marshal.FreeHGl obal(pDisplayBr ightness);
pDisplayBrightn ess = IntPtr.Zero;
}
}

static public void QuerySupportedB rightness()
{
IntPtr pAlloc = IntPtr.Zero;
IntPtr hDevice = IntPtr.Zero;

try
{
// Get a handle to the device.
hDevice = OpenLcdDevice() ;

Int64 i64 = 0;

// Create storage area in memory and get a handle to it.
pAlloc = Marshal.AllocHG lobal((int)512) ;
IntPtr pDest = pAlloc;

uint outputBufferSiz e = 512;
uint bytesReturned = 0;

bool fResult = DeviceIoControl (
hDevice,
WinIoCtlConstan ts.IOCTL_VIDEO_ QUERY_SUPPORTED _BRIGHTNESS,
IntPtr.Zero, // Set to NULL.
(uint)Marshal.S izeOf(i64), // Set to zero.
pDest, // Pointer to a buffer that receives an array of available
power levels.
outputBufferSiz e,
ref bytesReturned,
IntPtr.Zero);

Debug.WriteLine ("Bytes returned: " + bytesReturned.T oString());
Debug.WriteLine ("WIN32 Error: " +
Marshal.GetLast Win32Error().To String(), "QuerySupported Brightness");

if (!fResult)
{
Debug.WriteLine ("WIN32 Error: " +
Marshal.GetLast Win32Error().To String(), "QuerySupported Brightness");
throw new Exception(Marsh al.GetLastWin32 Error().ToStrin g());
}

Int64 StartingLcn = (Int64)Marshal. PtrToStructure( pDest, typeof(Int64));
}
catch(Exception ex)
{
Debug.WriteLine (ex.ToString()) ;
}
finally
{
CloseHandle(hDe vice);
hDevice = IntPtr.Zero;

Marshal.FreeHGl obal(pAlloc);
pAlloc = IntPtr.Zero;
}
}

[DllImport("kern el32.dll")]
public static extern IntPtr CreateFile(
string lpFileName, int dwDesiredAccess , int dwShareMode,
IntPtr lpSecurityAttri butes, int dwCreationDispo sition,
int dwFlagsAndAttri butes, IntPtr hTemplateFile );

private const int INVALID_HANDLE_ VALUE = -1;

// The DeviceIoControl Win32 function.
[DllImport("kern el32.dll", ExactSpelling=t rue) ]
internal static extern bool DeviceIoControl (
IntPtr hDevice, int dwIoControlCode , IntPtr lpInBuffer, int nInBufferSize,
IntPtr lpOutBuffer, int nOutBufferSize, ref int lpBytesReturned , IntPtr
lpOverlapped );
}
}