jwapowrprof.pas

比较全面的win32api开发包

{******************************************************************************}
{                                                       	               }
{ Power Policy Applicator interface Unit for Object Pascal                     }
{                                                       	               }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
{ Corporation. All Rights Reserved.                                            }
{ 								               }
{ The original file is: powrprof.h, released June 2000. The original Pascal    }
{ code is: PowrProf.pas, released August 2001. The initial developer of the    }
{ Pascal code is Marcel van Brakel ([e-mail]).                        }
{                                                                              }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
{ Marcel van Brakel. All Rights Reserved.                                      }
{ 								               }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
{								               }
{ You may retrieve the latest version of this file at the Project JEDI home    }
{ page, located at http://delphi-jedi.org or my personal homepage located at   }
{ http://members.chello.nl/m.vanbrakel2                                        }
{								               }
{ The contents of this file are used with permission, subject to the Mozilla   }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at      }
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
{                                                                              }
{ Software distributed under the License is distributed on an "AS IS" basis,   }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License.    }
{                                                                              }
{ Alternatively, the contents of this file may be used under the terms of the  }
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
{ provisions of the LGPL License are applicable instead of those above.        }
{ If you wish to allow use of your version of this file only under the terms   }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting  the provisions above and  }
{ replace  them with the notice and other provisions required by the LGPL      }
{ License.  If you do not delete the provisions above, a recipient may use     }
{ your version of this file under either the MPL or the LGPL License.          }
{ 								               }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ 								               }
{******************************************************************************}

unit JwaPowrProf;

{$WEAKPACKAGEUNIT}

{$HPPEMIT ''}
{$HPPEMIT '#include "powrprof.h"'}
{$HPPEMIT ''}

{$I WINDEFINES.INC}

interface

uses
  JwaWinNT, JwaWinType;

// Registry storage structures for the GLOBAL_POWER_POLICY data. There are two
// structures, GLOBAL_MACHINE_POWER_POLICY and GLOBAL_USER_POWER_POLICY. the
// GLOBAL_MACHINE_POWER_POLICY stores per machine data for which there is no UI.
// GLOBAL_USER_POWER_POLICY stores the per user data.

type
  PGLOBAL_MACHINE_POWER_POLICY = ^GLOBAL_MACHINE_POWER_POLICY;
  {$EXTERNALSYM PGLOBAL_MACHINE_POWER_POLICY}
  _GLOBAL_MACHINE_POWER_POLICY = record
    Revision: ULONG;
    LidOpenWakeAc: SYSTEM_POWER_STATE;
    LidOpenWakeDc: SYSTEM_POWER_STATE;
    BroadcastCapacityResolution: ULONG;
  end;
  {$EXTERNALSYM _GLOBAL_MACHINE_POWER_POLICY}
  GLOBAL_MACHINE_POWER_POLICY = _GLOBAL_MACHINE_POWER_POLICY;
  {$EXTERNALSYM GLOBAL_MACHINE_POWER_POLICY}
  TGlobalMachinePowerPolicy = GLOBAL_MACHINE_POWER_POLICY;
  PGlobalMachinePowerPolicy = PGLOBAL_MACHINE_POWER_POLICY;

  PGLOBAL_USER_POWER_POLICY = ^GLOBAL_USER_POWER_POLICY;
  {$EXTERNALSYM PGLOBAL_USER_POWER_POLICY}
  _GLOBAL_USER_POWER_POLICY = record
    Revision: ULONG;
    PowerButtonAc: POWER_ACTION_POLICY;
    PowerButtonDc: POWER_ACTION_POLICY;
    SleepButtonAc: POWER_ACTION_POLICY;
    SleepButtonDc: POWER_ACTION_POLICY;
    LidCloseAc: POWER_ACTION_POLICY;
    LidCloseDc: POWER_ACTION_POLICY;
    DischargePolicy: array [0..NUM_DISCHARGE_POLICIES - 1] of SYSTEM_POWER_LEVEL;
    GlobalFlags: ULONG;
  end;
  {$EXTERNALSYM _GLOBAL_USER_POWER_POLICY}
  GLOBAL_USER_POWER_POLICY = _GLOBAL_USER_POWER_POLICY;
  {$EXTERNALSYM GLOBAL_USER_POWER_POLICY}
  TGlobalUserPowerPolicy = GLOBAL_USER_POWER_POLICY;
  PGlobalUserPowerPolicy = PGLOBAL_USER_POWER_POLICY;

// Structure to manage global power policies at the user level. This structure
// contains data which is common across all power policy profiles.

  PGLOBAL_POWER_POLICY = ^GLOBAL_POWER_POLICY;
  {$EXTERNALSYM PGLOBAL_POWER_POLICY}
  _GLOBAL_POWER_POLICY = record
    user: GLOBAL_USER_POWER_POLICY;
    mach: GLOBAL_MACHINE_POWER_POLICY;
  end;
  {$EXTERNALSYM _GLOBAL_POWER_POLICY}
  GLOBAL_POWER_POLICY = _GLOBAL_POWER_POLICY;
  {$EXTERNALSYM GLOBAL_POWER_POLICY}
  TGlobalPowerPolicy = GLOBAL_POWER_POLICY;
  PGlobalPowerPolicy = PGLOBAL_POWER_POLICY;

// Registry storage structures for the POWER_POLICY data. There are three
// structures, MACHINE_POWER_POLICY, MACHINE_PROCESSOR_POWER_POLICY and USER_POWER_POLICY. the
// MACHINE_POWER_POLICY stores per machine data for which there is no UI.
// USER_POWER_POLICY stores the per user data.

  PMACHINE_POWER_POLICY = ^MACHINE_POWER_POLICY;
  {$EXTERNALSYM PMACHINE_POWER_POLICY}
  _MACHINE_POWER_POLICY = record
    Revision: ULONG; // 1
    // meaning of power action "sleep"
    MinSleepAc: SYSTEM_POWER_STATE;
    MinSleepDc: SYSTEM_POWER_STATE;
    ReducedLatencySleepAc: SYSTEM_POWER_STATE;
    ReducedLatencySleepDc: SYSTEM_POWER_STATE;
    // parameters for dozing
    DozeTimeoutAc: ULONG;
    DozeTimeoutDc: ULONG;
    DozeS4TimeoutAc: ULONG;
    DozeS4TimeoutDc: ULONG;
    // processor policies
    MinThrottleAc: UCHAR;
    MinThrottleDc: UCHAR;
    pad1: array [0..1] of UCHAR;
    OverThrottledAc: POWER_ACTION_POLICY;
    OverThrottledDc: POWER_ACTION_POLICY;
  end;
  {$EXTERNALSYM _MACHINE_POWER_POLICY}
  MACHINE_POWER_POLICY = _MACHINE_POWER_POLICY;
  {$EXTERNALSYM MACHINE_POWER_POLICY}
  TMachinePowerPolicy = MACHINE_POWER_POLICY;
  PMachinePowerPolicy = PMACHINE_POWER_POLICY;

  PMACHINE_PROCESSOR_POWER_POLICY = ^MACHINE_PROCESSOR_POWER_POLICY;
  {$EXTERNALSYM PMACHINE_PROCESSOR_POWER_POLICY}
  _MACHINE_PROCESSOR_POWER_POLICY = record
    Revision: ULONG; // 1
    ProcessorPolicyAc: PROCESSOR_POWER_POLICY;
    ProcessorPolicyDc: PROCESSOR_POWER_POLICY;
  end;
  {$EXTERNALSYM _MACHINE_PROCESSOR_POWER_POLICY}
  MACHINE_PROCESSOR_POWER_POLICY = _MACHINE_PROCESSOR_POWER_POLICY;
  {$EXTERNALSYM MACHINE_PROCESSOR_POWER_POLICY}
  TMachineProcessorPowerPolicy = MACHINE_PROCESSOR_POWER_POLICY;
  PMachineProcessorPowerPolicy = PMACHINE_PROCESSOR_POWER_POLICY;

  PUSER_POWER_POLICY = ^USER_POWER_POLICY;
  {$EXTERNALSYM PUSER_POWER_POLICY}
  _USER_POWER_POLICY = record
    Revision: ULONG; // 1
    // "system idle" detection
    IdleAc: POWER_ACTION_POLICY;
    IdleDc: POWER_ACTION_POLICY;
    IdleTimeoutAc: ULONG;
    IdleTimeoutDc: ULONG;
    IdleSensitivityAc: UCHAR;
    IdleSensitivityDc: UCHAR;
    // Throttling Policy
    ThrottlePolicyAc: UCHAR;
    ThrottlePolicyDc: UCHAR;
    // meaning of power action "sleep"
    MaxSleepAc: SYSTEM_POWER_STATE;
    MaxSleepDc: SYSTEM_POWER_STATE;
    // For future use
    Reserved: array [0..1] of ULONG;
    // video policies
    VideoTimeoutAc: ULONG;
    VideoTimeoutDc: ULONG;
    // hard disk policies
    SpindownTimeoutAc: ULONG;
    SpindownTimeoutDc: ULONG;
    // processor policies
    OptimizeForPowerAc: BOOLEAN;
    OptimizeForPowerDc: BOOLEAN;
    FanThrottleToleranceAc: UCHAR;
    FanThrottleToleranceDc: UCHAR;
    ForcedThrottleAc: UCHAR;
    ForcedThrottleDc: UCHAR;
  end;
  {$EXTERNALSYM _USER_POWER_POLICY}
  USER_POWER_POLICY = _USER_POWER_POLICY;
  {$EXTERNALSYM USER_POWER_POLICY}
  TUserPowerPolicy = USER_POWER_POLICY;
  PUserPowerPolicy = PUSER_POWER_POLICY;

// Structure to manage power policies at the user level. This structure
// contains data which is unique across power policy profiles.

  PPOWER_POLICY = ^POWER_POLICY;
  {$EXTERNALSYM PPOWER_POLICY}
  _POWER_POLICY = record
    user: USER_POWER_POLICY;
    mach: MACHINE_POWER_POLICY;
  end;
  {$EXTERNALSYM _POWER_POLICY}
  POWER_POLICY = _POWER_POLICY;
  {$EXTERNALSYM POWER_POLICY}
  TPowerPolicy = POWER_POLICY;
  PPowerPolicy = PPOWER_POLICY;

// Constants for GlobalFlags

const
  EnableSysTrayBatteryMeter = $01;
  {$EXTERNALSYM EnableSysTrayBatteryMeter}
  EnableMultiBatteryDisplay = $02;
  {$EXTERNALSYM EnableMultiBatteryDisplay}
  EnablePasswordLogon       = $04;
  {$EXTERNALSYM EnablePasswordLogon}
  EnableWakeOnRing          = $08;
  {$EXTERNALSYM EnableWakeOnRing}
  EnableVideoDimDisplay     = $10;
  {$EXTERNALSYM EnableVideoDimDisplay}

// This constant is passed as a uiID to WritePwrScheme.

  NEWSCHEME = UINT(-1);
  {$EXTERNALSYM NEWSCHEME}

// Prototype for EnumPwrSchemes callback proceedures.

// TODO REPLACE BOOLEAN WITH ...

type
  PWRSCHEMESENUMPROC = function (uiIndex: UINT; dwName: DWORD; sName: LPTSTR; dwDesc: DWORD; sDesc: LPTSTR; pp: PPOWER_POLICY; lParam: LPARAM): BOOLEAN; stdcall;
  {$EXTERNALSYM PWRSCHEMESENUMPROC}
  PFNNTINITIATEPWRACTION = function (pPowerAction: POWER_ACTION; SystemPowerState: SYSTEM_POWER_STATE; u: ULONG; b: BOOLEAN): BOOLEAN; stdcall;
  {$EXTERNALSYM PFNNTINITIATEPWRACTION}

// Public function prototypes

function GetPwrDiskSpindownRange(var RangeMax, RangeMin: UINT): BOOLEAN; stdcall;
{$EXTERNALSYM GetPwrDiskSpindownRange}
function EnumPwrSchemes(lpfnPwrSchemesEnumProc: PWRSCHEMESENUMPROC; lParam: LPARAM): BOOLEAN; stdcall;
{$EXTERNALSYM EnumPwrSchemes}
function ReadGlobalPwrPolicy(var pGlobalPowerPolicy: GLOBAL_POWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM ReadGlobalPwrPolicy}
function ReadPwrScheme(uiID: UINT; var pPowerPolicy: POWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM ReadPwrScheme}
function WritePwrScheme(puiID: PUINT; lpszName, lpszDescription: LPTSTR; const pPowerPolicy: POWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM WritePwrScheme}
function WriteGlobalPwrPolicy(const pGlobalPowerPolicy: GLOBAL_POWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM WriteGlobalPwrPolicy}
function DeletePwrScheme(uiIndex: UINT): BOOLEAN; stdcall;
{$EXTERNALSYM DeletePwrScheme}
function GetActivePwrScheme(var puiID: UINT): BOOLEAN; stdcall;
{$EXTERNALSYM GetActivePwrScheme}
function SetActivePwrScheme(uiID: UINT; pGlobalPowerPolicy: PGLOBAL_POWER_POLICY; pPowerPolicy: PPOWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM SetActivePwrScheme}
function GetPwrCapabilities(var lpSystemPowerCapabilities: SYSTEM_POWER_CAPABILITIES): BOOLEAN; stdcall;
{$EXTERNALSYM GetPwrCapabilities}
function IsPwrSuspendAllowed: BOOLEAN; stdcall;
{$EXTERNALSYM IsPwrSuspendAllowed}
function IsPwrHibernateAllowed: BOOLEAN; stdcall;
{$EXTERNALSYM IsPwrHibernateAllowed}
function IsPwrShutdownAllowed: BOOLEAN; stdcall;
{$EXTERNALSYM IsPwrShutdownAllowed}
function IsAdminOverrideActive(pAdministratorPowerPolicy: PADMINISTRATOR_POWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM IsAdminOverrideActive}
function SetSuspendState(Hibernate, ForceCritical, DisableWakeEvent: BOOLEAN): BOOLEAN; stdcall;
{$EXTERNALSYM SetSuspendState}
function GetCurrentPowerPolicies(pGlobalPowerPolicy: PGLOBAL_POWER_POLICY; pPowerPolicy: PPOWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM GetCurrentPowerPolicies}
function CanUserWritePwrScheme: BOOLEAN; stdcall;
{$EXTERNALSYM CanUserWritePwrScheme}
function ReadProcessorPwrScheme(uiID: UINT; var pMachineProcessorPowerPolicy: MACHINE_PROCESSOR_POWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM ReadProcessorPwrScheme}
function WriteProcessorPwrScheme(uiID: UINT; const pMachineProcessorPowerPolicy: MACHINE_PROCESSOR_POWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM WriteProcessorPwrScheme}
function ValidatePowerPolicies(GlobalPolicy: PGLOBAL_POWER_POLICY; Policy: PPOWER_POLICY): BOOLEAN; stdcall;
{$EXTERNALSYM ValidatePowerPolicies}

function CallNtPowerInformation(InformationLeveL: POWER_INFORMATION_LEVEL; lpInputBuffer: PVOID; nInputBufferSize: ULONG; lpOutputBuffer: PVOID; nOutputBufferSize: ULONG): NTSTATUS; stdcall;
{$EXTERNALSYM CallNtPowerInformation}

implementation

uses
  SysUtils;

const
  powrprof_lib = 'powrprof.dll';

{$IFDEF DYNAMIC_LINK}
var
  _GetPwrDiskSpindownRange: Pointer;

function GetPwrDiskSpindownRange;
begin
  GetProcedureAddress(_GetPwrDiskSpindownRange, powrprof_lib, 'GetPwrDiskSpindownRange');
  asm
    mov esp, ebp
    pop ebp
    jmp [_GetPwrDiskSpindownRange]
  end;
end;
{$ELSE}
function GetPwrDiskSpindownRange; external powrprof_lib name 'GetPwrDiskSpindownRange';
{$ENDIF DYNAMIC_LINK}

{$IFDEF DYNAMIC_LINK}
var
  _EnumPwrSchemes: Pointer;

function EnumPwrSchemes;
begin
  GetProcedureAddress(_EnumPwrSchemes, powrprof_lib, 'EnumPwrSchemes');
  asm
    mov esp, ebp
    pop ebp
    jmp [_EnumPwrSchemes]
  end;
end;
{$ELSE}
function EnumPwrSchemes; external powrprof_lib name 'EnumPwrSchemes';
{$ENDIF DYNAMIC_LINK}