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現在の構造体のリビジョンレベルです。電源ポリシーを設定するために USER_POWER_POLICY 構造体を使用する前に、GetCurrentPowerPolicies または ReadPwrScheme を呼び出してこの値を設定します。
IdleAcPOWER_ACTION_POLICY12+4+4システムが AC (商用) 電源で動作しているときにシステムのアイドルタイマーが満了した場合に開始するシステム電源アクションを定義する POWER_ACTION_POLICY 構造体です。
IdleDcPOWER_ACTION_POLICY12+16+16システムがバッテリー電源で動作しているときにシステムのアイドルタイマーが満了した場合に開始するシステム電源アクションを定義する POWER_ACTION_POLICY 構造体です。
IdleTimeoutAcDWORD4+28+28

AC (商用) 電源で動作しているときに、システムのアイドルタイマーが満了するまでにシステムの動作レベルがアイドル検出のしきい値を下回り続けなければならない時間 (秒単位) です。

ユーザーが不在の状態で自動再開を実行している場合、このメンバーは無視されます。アプリケーションが処理を実行している間、一時的にシステムを動作させ続けるには、SetThreadExecutionState 関数を使用してください。

IdleTimeoutDcDWORD4+32+32

バッテリー電源で動作しているときに、システムのアイドルタイマーが満了するまでにシステムの動作レベルがアイドル検出のしきい値を下回り続けなければならない時間 (秒単位) です。

ユーザーが不在の状態で自動再開を実行している場合、このメンバーは無視されます。アプリケーションが処理を実行している間、一時的にシステムを動作させ続けるには、SetThreadExecutionState 関数を使用してください。

IdleSensitivityAcBYTE1+36+36システムが AC (商用) 電源で動作しているときのアイドル検出のしきい値を定義するシステム動作レベルで、パーセンテージで表されます。
IdleSensitivityDcBYTE1+37+37システムがバッテリー電源で動作しているときのアイドル検出のしきい値を定義するシステム動作レベルで、パーセンテージで表されます。
ThrottlePolicyAcBYTE1+38+38システムが AC (商用) 電源で動作しているときに使用するプロセッサの動的スロットリングポリシーです。
ThrottlePolicyDcBYTE1+39+39システムがバッテリー電源で動作しているときに使用するプロセッサの動的スロットリングポリシーです。
MaxSleepAcSYSTEM_POWER_STATE4+40+40システムが AC (商用) 電源で動作しているときの最大のシステムスリープ状態です。このメンバーは SYSTEM_POWER_STATE 列挙型の値のいずれかでなければなりません。
MaxSleepDcSYSTEM_POWER_STATE4+44+44システムがバッテリー電源で動作しているときの最大のシステムスリープ状態です。このメンバーは SYSTEM_POWER_STATE 列挙型の値のいずれかでなければなりません。
ReservedDWORD8+48+48予約済みです。
VideoTimeoutAcDWORD4+56+56システムが AC (商用) 電源で動作しているときに、ディスプレイの電源が切られるまでの時間 (秒単位) です。
VideoTimeoutDcDWORD4+60+60システムがバッテリー電源で動作しているときに、ディスプレイの電源が切られるまでの時間 (秒単位) です。
SpindownTimeoutAcDWORD4+64+64システムが AC (商用) 電源で動作しているときに、固定ディスクドライブへの電源が切られるまでの時間 (秒単位) です。
SpindownTimeoutDcDWORD4+68+68システムがバッテリー電源で動作しているときに、固定ディスクドライブへの電源が切られるまでの時間 (秒単位) です。
OptimizeForPowerAcBOOLEAN1+72+72このメンバーが TRUE の場合、パッシブ冷却が指定されていてシステムが AC (商用) 電源で動作しているときに、システムは冷却ファンを作動させ、プロセッサを最高速度で動作させます。これにより、オペレーティングシステムはファンを使用してプロセッサを最高速度で動作させる方向に偏ります。
OptimizeForPowerDcBOOLEAN1+73+73このメンバーが TRUE の場合、パッシブ冷却が指定されていてシステムがバッテリー電源で動作しているときに、システムは冷却ファンを作動させ、プロセッサを最高速度で動作させます。これにより、オペレーティングシステムはファンを使用してプロセッサを最高速度で動作させる方向に偏ります。
FanThrottleToleranceAcBYTE1+74+74システムが AC (商用) 電源で動作しているときに、熱イベントに応じてシステムファンを作動させる前にプロセッサをスロットリングできる下限で、パーセンテージで表されます。
FanThrottleToleranceDcBYTE1+75+75システムがバッテリー電源で動作しているときに、熱イベントに応じてシステムファンを作動させる前にプロセッサをスロットリングできる下限で、パーセンテージで表されます。
ForcedThrottleAcBYTE1+76+76コンピューターが AC (商用) 電源で動作している間にシステムが課すプロセッサのスロットリングレベルで、パーセンテージで表されます。
ForcedThrottleDcBYTE1+77+77コンピューターがバッテリー電源で動作している間にシステムが課すプロセッサのスロットリングレベルで、パーセンテージで表されます。

公式ドキュメント

ユーザーごとに各電源スキームに固有の電源ポリシー設定を格納します。この構造体は POWER_POLICY 構造体の一部です。

出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での定義

#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