{>>DETERMINATION DE LA LUMINOSITE}
Function FindActualGamma : integer;
var
  hGammaDC : HDC;
  GammaArray: array[0..2,0..255] of word;
begin
  hGammaDC := GetDC(0);
  GetDeviceGammaRamp(hGammaDC, GammaArray);
  ReleaseDC(0, hGammaDC);
  result:=GammaArray[0,1]-128;
end;
{>>MODIFICATION DE LA LUMINOSITE }
Procedure ChangeLuminosity(Brightness: integer);
var
  hGammaDC : HDC;
  GammaArray: array[0..2] of array [0..255] of word;
  Index, ArrayValue: integer;
begin
  hGammaDC := GetDC(0);
  for Index := 0 to 255 do
    begin
    ArrayValue := Index * (Brightness + 128);
    if (ArrayValue > 65535) then ArrayValue := 65535;
    GammaArray[0,Index] := WORD(ArrayValue);
    GammaArray[1,Index] := WORD(ArrayValue);
    GammaArray[2,Index] := WORD(ArrayValue);
    end;
  SetDeviceGammaRamp(hGammaDC, GammaArray);
  ReleaseDC(0, hGammaDC);
end;
{>>DIMINUTION DE LA LUMINOSITE}
procedure TForm1.DownLuminosity_Bt(Sender: TObject);
Var
  i,ActualGamma : integer;
Begin
  ActualGamma:=FindActualGamma;
  For i:=ActualGamma downto 64 do ChangeLuminosity(i);
end;
{>>AUGMENTATION DE LA LUMINOSITE}
procedure TForm1.UpLuminosity_Bt(Sender: TObject);
Var
  i,ActualGamma : integer;
Begin
  ActualGamma:=FindActualGamma;
  For i:=ActualGamma to 128 do ChangeLuminosity(i);
end;

Private Declare Function GetDC Lib "user32" (ByVal hwnd As Long) As Long
Private Declare Function ReleaseDC Lib "user32" (ByVal hwnd As Long, ByVal hdc As Long) As Long
Private Declare Function GetDeviceGammaRamp Lib "gdi32" (ByVal hdc As Long, lpv As Any) As Long
Private Declare Function SetDeviceGammaRamp Lib "gdi32" (ByVal hdc As Long, lpRamp As Any) As Long
Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)

Private Sub SetBrightness(Brightness As Byte)
  Dim gammaDC As Long
  gammaDC = GetDC(0&)
  If Not gammaDC = 0& Then
    Dim i As Integer, arrayValue As Long, UIarrayValue As Integer
    Dim gammaArray(0 To 255, 0 To 2) As Integer
    For i = 0 To 255
      arrayValue = i * (CLng(Brightness) + 128)
      If arrayValue > 65535 Then arrayValue = 65535
      Call CopyMemory(UIarrayValue, arrayValue, LenB(UIarrayValue))
      gammaArray(i, 0) = UIarrayValue
      gammaArray(i, 1) = UIarrayValue
      gammaArray(i, 2) = UIarrayValue
    Next i
    Call SetDeviceGammaRamp(gammaDC, gammaArray(0, 0))
  End If
  Call ReleaseDC(0&, gammaDC)
End Sub

Private Function GetBrightness() As Byte
  Dim gammaDC As Long
  gammaDC = GetDC(0&)
  If Not gammaDC = 0& Then
    Dim gammaArray(0 To 255, 0 To 2) As Integer
    Call GetDeviceGammaRamp(gammaDC, gammaArray(0, 0))
    GetBrightness = CByte(gammaArray(1, 0) - 128)
  End If
  Call ReleaseDC(0&, gammaDC)
End Function

Imports System
Imports System.Runtime.InteropServices

Module ScreenBrightnessAdjustement
  <DllImport("user32")> _
  Private Function GetDC(ByVal Handle As IntPtr) As IntPtr
  End Function

  <DllImport("user32")> _
  Private Function ReleaseDC(ByVal Handle As IntPtr, ByVal DeviceContext As IntPtr) As Integer
  End Function

  <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Ansi)> _
  Private Structure RAMP
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=256)> Public Red() As UShort
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=256)> Public Green() As UShort
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=256)> Public Blue() As UShort
  End Structure

  <DllImport("gdi32")> _
  Private Function GetDeviceGammaRamp(ByVal DeviceContext As IntPtr, ByRef lpv As RAMP) As Integer
  End Function

  <DllImport("gdi32")> _
  Private Function SetDeviceGammaRamp(ByVal DeviceContext As IntPtr, ByRef lpv As RAMP) As Integer
  End Function

  Public Function GetBrightness() As Byte
    Dim Brightness As Byte = 0
    Dim gammaDC As IntPtr = GetDC(IntPtr.Zero)
    If Not gammaDC = IntPtr.Zero Then
      Dim gammaArray As RAMP = New RAMP()
      Call GetDeviceGammaRamp(gammaDC, gammaArray)
      Brightness = CByte(gammaArray.Red(1) - 128)
    End If
    Call ReleaseDC(IntPtr.Zero, gammaDC)
    Return Brightness
  End Function

  Public Sub SetBrightness(ByVal Brightness As Byte)
    Dim gammaDC As IntPtr = GetDC(IntPtr.Zero)
    If Not gammaDC = IntPtr.Zero Then
      Dim gammaArray As RAMP = New RAMP()
      gammaArray.Red = CType(Array.CreateInstance(GetType(UShort), 256), UShort())
      gammaArray.Green = CType(Array.CreateInstance(GetType(UShort), 256), UShort())
      gammaArray.Blue = CType(Array.CreateInstance(GetType(UShort), 256), UShort())
      For i As Int16 = 0 To 255
        Dim arrayValue As UShort = CUShort(Math.Min(i * (Brightness + 128), UShort.MaxValue))
        gammaArray.Red(i) = arrayValue
        gammaArray.Green(i) = arrayValue
        gammaArray.Blue(i) = arrayValue
      Next i
      Call SetDeviceGammaRamp(gammaDC, gammaArray)
    End If
    Call ReleaseDC(IntPtr.Zero, gammaDC)
  End Sub

End Module

using System;
using System.Runtime.InteropServices;

static class ScreenBrightnessAdjustement {
  [DllImport("user32")]
  private static extern IntPtr GetDC(IntPtr Handle);

  [DllImport("user32")]
  private static extern int ReleaseDC(IntPtr Handle, IntPtr DeviceContext);

  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
  private struct RAMP {
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
    public ushort[] Red;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
    public ushort[] Green;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
    public ushort[] Blue;
  }

  [DllImport("gdi32")]
  private static extern int GetDeviceGammaRamp(IntPtr DeviceContext, ref RAMP lpv);

  [DllImport("gdi32")]
  private static extern int SetDeviceGammaRamp(IntPtr DeviceContext, ref RAMP lpv);

  public static byte GetBrightness() {
    byte Brightness = 0;
    IntPtr gammaDC = GetDC(IntPtr.Zero);
    if (gammaDC != System.IntPtr.Zero) {
      RAMP gammaArray = new RAMP();
      GetDeviceGammaRamp(gammaDC, ref gammaArray);
      Brightness = (byte)(gammaArray.Red[1] - 128);
    }
    ReleaseDC(IntPtr.Zero, gammaDC);
    return Brightness;
  }

  public static void SetBrightness(byte Brightness) {
    IntPtr gammaDC = GetDC(IntPtr.Zero);
    if (gammaDC != System.IntPtr.Zero) {
      RAMP gammaArray = new RAMP();
      gammaArray.Red = new ushort[256];
      gammaArray.Green = new ushort[256];
      gammaArray.Blue = new ushort[256];
      for (int i = 0; i < 256; i++)
        gammaArray.Red[i] = gammaArray.Green[i] = gammaArray.Blue[i] = (ushort)Math.Min(i * (Brightness + 128), ushort.MaxValue);
      SetDeviceGammaRamp(gammaDC, ref gammaArray);
    }
    ReleaseDC(IntPtr.Zero, gammaDC);
  }
}