Win32 API 日本語リファレンス
ホーム › System.Power › USER_POWER_POLICY

USER_POWER_POLICY

構造体
📘 Microsoft Learn (日本語) · English
サイズx64: 80 バイト / x86: 80 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド型サイズx64x86説明
RevisionDWORD4+0+0ポリシー構造体のリビジョン番号である。
IdleAcPOWER_ACTION_POLICY12+4+4AC電源時、アイドル時に行う動作(POWER_ACTION_POLICY)である。
IdleDcPOWER_ACTION_POLICY12+16+16バッテリ時、アイドル時に行う動作である。
IdleTimeoutAcDWORD4+28+28AC電源時、アイドル動作までの時間(秒)である。
IdleTimeoutDcDWORD4+32+32バッテリ時、アイドル動作までの時間(秒)である。
IdleSensitivityAcBYTE1+36+36AC電源時のアイドル判定感度(パーセント)である。
IdleSensitivityDcBYTE1+37+37バッテリ時のアイドル判定感度(パーセント)である。
ThrottlePolicyAcBYTE1+38+38AC電源時のプロセッサスロットルポリシーである。
ThrottlePolicyDcBYTE1+39+39バッテリ時のプロセッサスロットルポリシーである。
MaxSleepAcSYSTEM_POWER_STATE4+40+40AC電源時の最大スリープ状態(SYSTEM_POWER_STATE)である。
MaxSleepDcSYSTEM_POWER_STATE4+44+44バッテリ時の最大スリープ状態である。
ReservedDWORD8+48+48予約フィールドである。0となる。
VideoTimeoutAcDWORD4+56+56AC電源時、ディスプレイをオフにするまでの時間(秒)である。
VideoTimeoutDcDWORD4+60+60バッテリ時、ディスプレイをオフにするまでの時間(秒)である。
SpindownTimeoutAcDWORD4+64+64AC電源時、ディスクを停止するまでの時間(秒)である。
SpindownTimeoutDcDWORD4+68+68バッテリ時、ディスクを停止するまでの時間(秒)である。
OptimizeForPowerAcBOOLEAN1+72+72AC電源時、省電力を優先するかを示すBOOLEANである。
OptimizeForPowerDcBOOLEAN1+73+73バッテリ時、省電力を優先するかを示すBOOLEANである。
FanThrottleToleranceAcBYTE1+74+74AC電源時のファンスロットル許容率(パーセント)である。
FanThrottleToleranceDcBYTE1+75+75バッテリ時のファンスロットル許容率(パーセント)である。
ForcedThrottleAcBYTE1+76+76AC電源時に強制適用するスロットル率(パーセント)である。
ForcedThrottleDcBYTE1+77+77バッテリ時に強制適用するスロットル率(パーセント)である。

各言語での定義

#include <windows.h>

// POWER_ACTION_POLICY  (x64 12 / x86 12 バイト)
typedef struct POWER_ACTION_POLICY {
    POWER_ACTION Action;
    DWORD Flags;
    POWER_ACTION_POLICY_EVENT_CODE EventCode;
} POWER_ACTION_POLICY;

// USER_POWER_POLICY  (x64 80 / x86 80 バイト)
typedef struct USER_POWER_POLICY {
    DWORD Revision;
    POWER_ACTION_POLICY IdleAc;
    POWER_ACTION_POLICY IdleDc;
    DWORD IdleTimeoutAc;
    DWORD IdleTimeoutDc;
    BYTE IdleSensitivityAc;
    BYTE IdleSensitivityDc;
    BYTE ThrottlePolicyAc;
    BYTE ThrottlePolicyDc;
    SYSTEM_POWER_STATE MaxSleepAc;
    SYSTEM_POWER_STATE MaxSleepDc;
    DWORD Reserved[2];
    DWORD VideoTimeoutAc;
    DWORD VideoTimeoutDc;
    DWORD SpindownTimeoutAc;
    DWORD SpindownTimeoutDc;
    BOOLEAN OptimizeForPowerAc;
    BOOLEAN OptimizeForPowerDc;
    BYTE FanThrottleToleranceAc;
    BYTE FanThrottleToleranceDc;
    BYTE ForcedThrottleAc;
    BYTE ForcedThrottleDc;
} USER_POWER_POLICY;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct POWER_ACTION_POLICY
{
    public int Action;
    public uint Flags;
    public uint EventCode;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct USER_POWER_POLICY
{
    public uint Revision;
    public POWER_ACTION_POLICY IdleAc;
    public POWER_ACTION_POLICY IdleDc;
    public uint IdleTimeoutAc;
    public uint IdleTimeoutDc;
    public byte IdleSensitivityAc;
    public byte IdleSensitivityDc;
    public byte ThrottlePolicyAc;
    public byte ThrottlePolicyDc;
    public int MaxSleepAc;
    public int MaxSleepDc;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public uint[] Reserved;
    public uint VideoTimeoutAc;
    public uint VideoTimeoutDc;
    public uint SpindownTimeoutAc;
    public uint SpindownTimeoutDc;
    [MarshalAs(UnmanagedType.U1)] public bool OptimizeForPowerAc;
    [MarshalAs(UnmanagedType.U1)] public bool OptimizeForPowerDc;
    public byte FanThrottleToleranceAc;
    public byte FanThrottleToleranceDc;
    public byte ForcedThrottleAc;
    public byte ForcedThrottleDc;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure POWER_ACTION_POLICY
    Public Action As Integer
    Public Flags As UInteger
    Public EventCode As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure USER_POWER_POLICY
    Public Revision As UInteger
    Public IdleAc As POWER_ACTION_POLICY
    Public IdleDc As POWER_ACTION_POLICY
    Public IdleTimeoutAc As UInteger
    Public IdleTimeoutDc As UInteger
    Public IdleSensitivityAc As Byte
    Public IdleSensitivityDc As Byte
    Public ThrottlePolicyAc As Byte
    Public ThrottlePolicyDc As Byte
    Public MaxSleepAc As Integer
    Public MaxSleepDc As Integer
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=2)> Public Reserved() As UInteger
    Public VideoTimeoutAc As UInteger
    Public VideoTimeoutDc As UInteger
    Public SpindownTimeoutAc As UInteger
    Public SpindownTimeoutDc As UInteger
    <MarshalAs(UnmanagedType.U1)> Public OptimizeForPowerAc As Boolean
    <MarshalAs(UnmanagedType.U1)> Public OptimizeForPowerDc As Boolean
    Public FanThrottleToleranceAc As Byte
    Public FanThrottleToleranceDc As Byte
    Public ForcedThrottleAc As Byte
    Public ForcedThrottleDc As Byte
End Structure
import ctypes
from ctypes import wintypes

class POWER_ACTION_POLICY(ctypes.Structure):
    _fields_ = [
        ("Action", ctypes.c_int),
        ("Flags", wintypes.DWORD),
        ("EventCode", wintypes.DWORD),
    ]

class USER_POWER_POLICY(ctypes.Structure):
    _fields_ = [
        ("Revision", wintypes.DWORD),
        ("IdleAc", POWER_ACTION_POLICY),
        ("IdleDc", POWER_ACTION_POLICY),
        ("IdleTimeoutAc", wintypes.DWORD),
        ("IdleTimeoutDc", wintypes.DWORD),
        ("IdleSensitivityAc", ctypes.c_ubyte),
        ("IdleSensitivityDc", ctypes.c_ubyte),
        ("ThrottlePolicyAc", ctypes.c_ubyte),
        ("ThrottlePolicyDc", ctypes.c_ubyte),
        ("MaxSleepAc", ctypes.c_int),
        ("MaxSleepDc", ctypes.c_int),
        ("Reserved", wintypes.DWORD * 2),
        ("VideoTimeoutAc", wintypes.DWORD),
        ("VideoTimeoutDc", wintypes.DWORD),
        ("SpindownTimeoutAc", wintypes.DWORD),
        ("SpindownTimeoutDc", wintypes.DWORD),
        ("OptimizeForPowerAc", ctypes.c_byte),
        ("OptimizeForPowerDc", ctypes.c_byte),
        ("FanThrottleToleranceAc", ctypes.c_ubyte),
        ("FanThrottleToleranceDc", ctypes.c_ubyte),
        ("ForcedThrottleAc", ctypes.c_ubyte),
        ("ForcedThrottleDc", ctypes.c_ubyte),
    ]
#[repr(C)]
pub struct POWER_ACTION_POLICY {
    pub Action: i32,
    pub Flags: u32,
    pub EventCode: u32,
}

#[repr(C)]
pub struct USER_POWER_POLICY {
    pub Revision: u32,
    pub IdleAc: POWER_ACTION_POLICY,
    pub IdleDc: POWER_ACTION_POLICY,
    pub IdleTimeoutAc: u32,
    pub IdleTimeoutDc: u32,
    pub IdleSensitivityAc: u8,
    pub IdleSensitivityDc: u8,
    pub ThrottlePolicyAc: u8,
    pub ThrottlePolicyDc: u8,
    pub MaxSleepAc: i32,
    pub MaxSleepDc: i32,
    pub Reserved: [u32; 2],
    pub VideoTimeoutAc: u32,
    pub VideoTimeoutDc: u32,
    pub SpindownTimeoutAc: u32,
    pub SpindownTimeoutDc: u32,
    pub OptimizeForPowerAc: u8,
    pub OptimizeForPowerDc: u8,
    pub FanThrottleToleranceAc: u8,
    pub FanThrottleToleranceDc: u8,
    pub ForcedThrottleAc: u8,
    pub ForcedThrottleDc: u8,
}
import "golang.org/x/sys/windows"

type POWER_ACTION_POLICY struct {
	Action int32
	Flags uint32
	EventCode uint32
}

type USER_POWER_POLICY struct {
	Revision uint32
	IdleAc POWER_ACTION_POLICY
	IdleDc POWER_ACTION_POLICY
	IdleTimeoutAc uint32
	IdleTimeoutDc uint32
	IdleSensitivityAc byte
	IdleSensitivityDc byte
	ThrottlePolicyAc byte
	ThrottlePolicyDc byte
	MaxSleepAc int32
	MaxSleepDc int32
	Reserved [2]uint32
	VideoTimeoutAc uint32
	VideoTimeoutDc uint32
	SpindownTimeoutAc uint32
	SpindownTimeoutDc uint32
	OptimizeForPowerAc byte
	OptimizeForPowerDc byte
	FanThrottleToleranceAc byte
	FanThrottleToleranceDc byte
	ForcedThrottleAc byte
	ForcedThrottleDc byte
}
type
  POWER_ACTION_POLICY = record
    Action: Integer;
    Flags: DWORD;
    EventCode: DWORD;
  end;

  USER_POWER_POLICY = record
    Revision: DWORD;
    IdleAc: POWER_ACTION_POLICY;
    IdleDc: POWER_ACTION_POLICY;
    IdleTimeoutAc: DWORD;
    IdleTimeoutDc: DWORD;
    IdleSensitivityAc: Byte;
    IdleSensitivityDc: Byte;
    ThrottlePolicyAc: Byte;
    ThrottlePolicyDc: Byte;
    MaxSleepAc: Integer;
    MaxSleepDc: Integer;
    Reserved: array[0..1] of DWORD;
    VideoTimeoutAc: DWORD;
    VideoTimeoutDc: DWORD;
    SpindownTimeoutAc: DWORD;
    SpindownTimeoutDc: DWORD;
    OptimizeForPowerAc: ByteBool;
    OptimizeForPowerDc: ByteBool;
    FanThrottleToleranceAc: Byte;
    FanThrottleToleranceDc: Byte;
    ForcedThrottleAc: Byte;
    ForcedThrottleDc: Byte;
  end;
const POWER_ACTION_POLICY = extern struct {
    Action: i32,
    Flags: u32,
    EventCode: u32,
};

const USER_POWER_POLICY = extern struct {
    Revision: u32,
    IdleAc: POWER_ACTION_POLICY,
    IdleDc: POWER_ACTION_POLICY,
    IdleTimeoutAc: u32,
    IdleTimeoutDc: u32,
    IdleSensitivityAc: u8,
    IdleSensitivityDc: u8,
    ThrottlePolicyAc: u8,
    ThrottlePolicyDc: u8,
    MaxSleepAc: i32,
    MaxSleepDc: i32,
    Reserved: [2]u32,
    VideoTimeoutAc: u32,
    VideoTimeoutDc: u32,
    SpindownTimeoutAc: u32,
    SpindownTimeoutDc: u32,
    OptimizeForPowerAc: u8,
    OptimizeForPowerDc: u8,
    FanThrottleToleranceAc: u8,
    FanThrottleToleranceDc: u8,
    ForcedThrottleAc: u8,
    ForcedThrottleDc: u8,
};
type
  POWER_ACTION_POLICY {.bycopy.} = object
    Action: int32
    Flags: uint32
    EventCode: uint32

  USER_POWER_POLICY {.bycopy.} = object
    Revision: uint32
    IdleAc: POWER_ACTION_POLICY
    IdleDc: POWER_ACTION_POLICY
    IdleTimeoutAc: uint32
    IdleTimeoutDc: uint32
    IdleSensitivityAc: uint8
    IdleSensitivityDc: uint8
    ThrottlePolicyAc: uint8
    ThrottlePolicyDc: uint8
    MaxSleepAc: int32
    MaxSleepDc: int32
    Reserved: array[2, uint32]
    VideoTimeoutAc: uint32
    VideoTimeoutDc: uint32
    SpindownTimeoutAc: uint32
    SpindownTimeoutDc: uint32
    OptimizeForPowerAc: uint8
    OptimizeForPowerDc: uint8
    FanThrottleToleranceAc: uint8
    FanThrottleToleranceDc: uint8
    ForcedThrottleAc: uint8
    ForcedThrottleDc: uint8
struct POWER_ACTION_POLICY
{
    int Action;
    uint Flags;
    uint EventCode;
}

struct USER_POWER_POLICY
{
    uint Revision;
    POWER_ACTION_POLICY IdleAc;
    POWER_ACTION_POLICY IdleDc;
    uint IdleTimeoutAc;
    uint IdleTimeoutDc;
    ubyte IdleSensitivityAc;
    ubyte IdleSensitivityDc;
    ubyte ThrottlePolicyAc;
    ubyte ThrottlePolicyDc;
    int MaxSleepAc;
    int MaxSleepDc;
    uint[2] Reserved;
    uint VideoTimeoutAc;
    uint VideoTimeoutDc;
    uint SpindownTimeoutAc;
    uint SpindownTimeoutDc;
    ubyte OptimizeForPowerAc;
    ubyte OptimizeForPowerDc;
    ubyte FanThrottleToleranceAc;
    ubyte FanThrottleToleranceDc;
    ubyte ForcedThrottleAc;
    ubyte ForcedThrottleDc;
}

HSP用 定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; USER_POWER_POLICY サイズ: 80 バイト(x64)
dim st, 20    ; 4byte整数×20(構造体サイズ 80 / 4 切り上げ)
; Revision : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; IdleAc : POWER_ACTION_POLICY (+4, 12byte)  varptr(st)+4 を基点に操作(12byte:入れ子/配列)
; IdleDc : POWER_ACTION_POLICY (+16, 12byte)  varptr(st)+16 を基点に操作(12byte:入れ子/配列)
; IdleTimeoutAc : DWORD (+28, 4byte)  st.7 = 値  /  値 = st.7   (lpoke/lpeek も可)
; IdleTimeoutDc : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; IdleSensitivityAc : BYTE (+36, 1byte)  poke st,36,値  /  値 = peek(st,36)
; IdleSensitivityDc : BYTE (+37, 1byte)  poke st,37,値  /  値 = peek(st,37)
; ThrottlePolicyAc : BYTE (+38, 1byte)  poke st,38,値  /  値 = peek(st,38)
; ThrottlePolicyDc : BYTE (+39, 1byte)  poke st,39,値  /  値 = peek(st,39)
; MaxSleepAc : SYSTEM_POWER_STATE (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; MaxSleepDc : SYSTEM_POWER_STATE (+44, 4byte)  st.11 = 値  /  値 = st.11   (lpoke/lpeek も可)
; Reserved : DWORD (+48, 8byte)  varptr(st)+48 を基点に操作(8byte:入れ子/配列)
; VideoTimeoutAc : DWORD (+56, 4byte)  st.14 = 値  /  値 = st.14   (lpoke/lpeek も可)
; VideoTimeoutDc : DWORD (+60, 4byte)  st.15 = 値  /  値 = st.15   (lpoke/lpeek も可)
; SpindownTimeoutAc : DWORD (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; SpindownTimeoutDc : DWORD (+68, 4byte)  st.17 = 値  /  値 = st.17   (lpoke/lpeek も可)
; OptimizeForPowerAc : BOOLEAN (+72, 1byte)  poke st,72,値  /  値 = peek(st,72)
; OptimizeForPowerDc : BOOLEAN (+73, 1byte)  poke st,73,値  /  値 = peek(st,73)
; FanThrottleToleranceAc : BYTE (+74, 1byte)  poke st,74,値  /  値 = peek(st,74)
; FanThrottleToleranceDc : BYTE (+75, 1byte)  poke st,75,値  /  値 = peek(st,75)
; ForcedThrottleAc : BYTE (+76, 1byte)  poke st,76,値  /  値 = peek(st,76)
; ForcedThrottleDc : BYTE (+77, 1byte)  poke st,77,値  /  値 = peek(st,77)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global POWER_ACTION_POLICY
    #field int Action
    #field int Flags
    #field int EventCode
#endstruct

#defstruct global USER_POWER_POLICY
    #field int Revision
    #field POWER_ACTION_POLICY IdleAc
    #field POWER_ACTION_POLICY IdleDc
    #field int IdleTimeoutAc
    #field int IdleTimeoutDc
    #field byte IdleSensitivityAc
    #field byte IdleSensitivityDc
    #field byte ThrottlePolicyAc
    #field byte ThrottlePolicyDc
    #field int MaxSleepAc
    #field int MaxSleepDc
    #field int Reserved 2
    #field int VideoTimeoutAc
    #field int VideoTimeoutDc
    #field int SpindownTimeoutAc
    #field int SpindownTimeoutDc
    #field bool1 OptimizeForPowerAc
    #field bool1 OptimizeForPowerDc
    #field byte FanThrottleToleranceAc
    #field byte FanThrottleToleranceDc
    #field byte ForcedThrottleAc
    #field byte ForcedThrottleDc
#endstruct

stdim st, USER_POWER_POLICY        ; NSTRUCT 変数を確保
st->Revision = 100
mes "Revision=" + st->Revision