www.pudn.com > HIDClass.zip > DBT.pas
{******************************************************************}
{ }
{ Borland Delphi Runtime Library }
{ interface unit }
{ }
{ Portions created by Microsoft are }
{ Copyright (C) 1993-1998 Microsoft Corporation. }
{ All Rights Reserved. }
{ }
{ The original file is: dbt.h, released 24 May 1993 }
{ The original Pascal code is: dbt.pas, released 01 Jan 1998 }
{ The initial developer of the Pascal code is Tom Deprez }
{ (Tom.Deprez@village.uunet.be) }
{ }
{ Portions created by Tom Deprez are }
{ Copyright (C) 1999-2000 Tom Deprez. }
{ }
{ Contributor(s): }
{ Robert Marquardt : pointed out that TWMDeviceChange }
{ is better placed inside dbt.pas }
{ }
{ }
{ 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 }
{ }
{ 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. }
{ }
{******************************************************************}
unit DBT;
interface
(*$HPPEMIT '' *)
(*$HPPEMIT '#include ' *)
(*$HPPEMIT '' *)
uses
Windows;
{ *
* BroadcastSpecialMessage constants
* }
const
{$EXTERNALSYM WM_DEVICECHANGE}
WM_DEVICECHANGE = $0219;
{ *
* Broadcast message and receipient flags.
*
* Note that there is a third "flag". If the wParam has:
*
* bit 15 on: lparam is a pointer and bit 14 is meaningfull.
* bit 15 off: lparam is just a UNLONG data type.
*
* bit 14 on: lparam is a pointer to an ASCIIZ string.
* bit 14 off: lparam is a pointer to a binary struture starting with
* a dword describing the length of the structure.
* }
const
{$EXTERNALSYM BSF_QUERY}
BSF_QUERY = $00000001;
{$EXTERNALSYM BSF_IGNORECURRENTTASK}
BSF_IGNORECURRENTTASK = $00000002; { Meaningless for VxDs }
{$EXTERNALSYM BSF_FLUSHDISK}
BSF_FLUSHDISK = $00000004; { Shouldn't be used by VxDs }
{$EXTERNALSYM BSF_NOHANG}
BSF_NOHANG = $00000008;
{$EXTERNALSYM BSF_POSTMESSAGE}
BSF_POSTMESSAGE = $00000010;
{$EXTERNALSYM BSF_FORCEIFHUNG}
BSF_FORCEIFHUNG = $00000020;
{$EXTERNALSYM BSF_NOTIMEOUTIFNOTHUNG}
BSF_NOTIMEOUTIFNOTHUNG = $00000040;
{$EXTERNALSYM BSF_MSGSRV32ISOK}
BSF_MSGSRV32ISOK = DWORD($80000000); { Called synchronously from PM API }
{$EXTERNALSYM BSF_MSGSRV32ISOK_BIT}
BSF_MSGSRV32ISOK_BIT = 31; { Called synchronously from PM API }
{$EXTERNALSYM BSM_ALLCOMPONENTS}
BSM_ALLCOMPONENTS = $00000000;
{$EXTERNALSYM BSM_VXDS}
BSM_VXDS = $00000001;
{$EXTERNALSYM BSM_NETDRIVER}
BSM_NETDRIVER = $00000002;
{$EXTERNALSYM BSM_INSTALLABLEDRIVERS}
BSM_INSTALLABLEDRIVERS = $00000004;
{$EXTERNALSYM BSM_APPLICATIONS}
BSM_APPLICATIONS = $00000008;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_APPYBEGIN
* lParam = (not used)
*
* 'Appy-time is now available. This message is itself sent
* at 'Appy-time.
*
* Message = WM_DEVICECHANGE
* wParam = DBT_APPYEND
* lParam = (not used)
*
* 'Appy-time is no longer available. This message is*NOT* sent
* at 'Appy-time. (It cannot be, because 'Appy-time is gone.)
*
* NOTE! It is possible for DBT_APPYBEGIN and DBT_APPYEND to be sent
* multiple times during a single Windows session. Each appearance of
* 'Appy-time is bracketed by these two messages, but 'Appy-time may
* momentarily become unavailable during otherwise normal Windows
* processing. The current status of 'Appy-time availability can always
* be obtained from a call to _SHELL_QueryAppyTimeAvailable.
* }
const
{$EXTERNALSYM DBT_APPYBEGIN}
DBT_APPYBEGIN = $0000;
{$EXTERNALSYM DBT_APPYEND}
DBT_APPYEND = $0001;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_DEVNODES_CHANGED
* lParam = 0
*
* send when configmg finished a process tree batch. Some devnodes
* may have been added or removed. This is used by ring3 people which
* need to be refreshed whenever any devnode changed occur (like
* device manager). People specific to certain devices should use
* DBT_DEVICE* instead.
* }
const
{$EXTERNALSYM DBT_DEVNODES_CHANGED}
DBT_DEVNODES_CHANGED = $0007;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_QUERYCHANGECONFIG
* lParam = 0
*
* sent to ask if a config change is allowed
* }
const
{$EXTERNALSYM DBT_QUERYCHANGECONFIG}
DBT_QUERYCHANGECONFIG = $0017;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_CONFIGCHANGED
* lParam = 0
*
* sent when a config has changed
* }
const
{$EXTERNALSYM DBT_CONFIGCHANGED}
DBT_CONFIGCHANGED = $0018;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_CONFIGCHANGECANCELED
* lParam = 0
*
* someone cancelled the config change
* }
const
{$EXTERNALSYM DBT_CONFIGCHANGECANCELED}
DBT_CONFIGCHANGECANCELED = $0019;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_MONITORCHANGE
* lParam = new resolution to use (LOWORD=x, HIWORD=y)
* if 0, use the default res for current config
*
* this message is sent when the display monitor has changed
* and the system should change the display mode to match it.
* }
const
{$EXTERNALSYM DBT_MONITORCHANGE}
DBT_MONITORCHANGE = $001B;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_SHELLLOGGEDON
* lParam = 0
*
* The shell has finished login on: VxD can now do Shell_EXEC.
* }
const
{$EXTERNALSYM DBT_SHELLLOGGEDON}
DBT_SHELLLOGGEDON = $0020;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_CONFIGMGAPI
* lParam = CONFIGMG API Packet
*
* CONFIGMG ring 3 call.
* }
const
{$EXTERNALSYM DBT_CONFIGMGAPI32}
DBT_CONFIGMGAPI32 = $0022;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_VXDINITCOMPLETE
* lParam = 0
*
* CONFIGMG ring 3 call.
*
const
{$EXTERNALSYM DBT_VXDINITCOMPLETE}
DBT_VXDINITCOMPLETE = $0023;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_VOLLOCK*
* lParam = pointer to VolLockBroadcast structure described below
*
* Messages issued by IFSMGR for volume locking purposes on WM_DEVICECHANGE.
* All these messages pass a pointer to a struct which has no pointers.
* }
const
{$EXTERNALSYM DBT_VOLLOCKQUERYLOCK}
DBT_VOLLOCKQUERYLOCK = $8041;
{$EXTERNALSYM DBT_VOLLOCKLOCKTAKEN}
DBT_VOLLOCKLOCKTAKEN = $8042;
{$EXTERNALSYM DBT_VOLLOCKLOCKFAILED}
DBT_VOLLOCKLOCKFAILED = $8043;
{$EXTERNALSYM DBT_VOLLOCKQUERYUNLOCK}
DBT_VOLLOCKQUERYUNLOCK = $8044;
{$EXTERNALSYM DBT_VOLLOCKLOCKRELEASED}
DBT_VOLLOCKLOCKRELEASED = $8045;
{$EXTERNALSYM DBT_VOLLOCKUNLOCKFAILED}
DBT_VOLLOCKUNLOCKFAILED = $8046;
{ *
* Device broadcast header
* }
type
PDevBroadcastHdr = ^TDevBroadcastHdr;
{$EXTERNALSYM _DEV_BROADCAST_HDR}
_DEV_BROADCAST_HDR = packed record
dbch_size: DWORD;
dbch_devicetype: DWORD;
dbch_reserved: DWORD;
end;
TDevBroadcastHdr = _DEV_BROADCAST_HDR;
{$EXTERNALSYM DEV_BROADCAST_HDR}
DEV_BROADCAST_HDR = _DEV_BROADCAST_HDR;
{ *
* Structure for volume lock broadcast
* }
type
PVolLockBroadcast = ^TVolLockBroadcast;
{$EXTERNALSYM VolLockBroadcast}
VolLockBroadcast = packed record
vlb_dbh: TDevBroadcastHdr;
vlb_owner: DWORD;
vlb_perms: Byte;
vlb_lockType: Byte;
vlb_drive: Byte;
vlb_flags: Byte;
end;
TVolLockBroadcast = VolLockBroadcast;
{ *
* Values for vlb_perms
* }
const
{$EXTERNALSYM LOCKP_ALLOW_WRITES}
LOCKP_ALLOW_WRITES = $01; { Bit 0 set - allow writes }
{$EXTERNALSYM LOCKP_FAIL_WRITES}
LOCKP_FAIL_WRITES = $00; { Bit 0 clear - fail writes }
{$EXTERNALSYM LOCKP_FAIL_MEM_MAPPING}
LOCKP_FAIL_MEM_MAPPING = $02; { Bit 1 set - fail memory mappings }
{$EXTERNALSYM LOCKP_ALLOW_MEM_MAPPING}
LOCKP_ALLOW_MEM_MAPPING = $00; { Bit 1 clear - allow memory mappings }
{$EXTERNALSYM LOCKP_USER_MASK}
LOCKP_USER_MASK = $03; { Mask for user lock flags }
{$EXTERNALSYM LOCKP_LOCK_FOR_FORMAT}
LOCKP_LOCK_FOR_FORMAT = $04; { Level 0 lock for format }
{ *
* Values for vlb_flags
* }
const
{$EXTERNALSYM LOCKF_LOGICAL_LOCK}
LOCKF_LOGICAL_LOCK = $00; { Bit 0 clear - logical lock }
{$EXTERNALSYM LOCKF_PHYSICAL_LOCK}
LOCKF_PHYSICAL_LOCK = $01; { Bit 0 set - physical lock }
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_NODISKSPACE
* lParam = drive number of drive that is out of disk space (1-based)
*
* Message issued by IFS manager when it detects that a drive is run out of
* free space.
* }
const
{$EXTERNALSYM DBT_NO_DISK_SPACE}
DBT_NO_DISK_SPACE = $0047;
{ *
* Message = WM_DEVICECHANGE
* wParam = DBT_LOW_DISK_SPACE
* lParam = drive number of drive that is low on disk space (1-based)
*
* Message issued by VFAT when it detects that a drive it has mounted
* has the remaning free space below a threshold specified by the
* registry or by a disk space management application.
* The broadcast is issued by VFAT ONLY when space is either allocated
* or freed by VFAT.
* }
const
{$EXTERNALSYM DBT_LOW_DISK_SPACE}
DBT_LOW_DISK_SPACE = $0048;
{$EXTERNALSYM DBT_CONFIGMGPRIVATE}
DBT_CONFIGMGPRIVATE = $7FFF;
{ *
* The following messages are for WM_DEVICECHANGE. The immediate list
* is for the wParam. ALL THESE MESSAGES PASS A POINTER TO A STRUCT
* STARTING WITH A DWORD SIZE AND HAVING NO POINTER IN THE STRUCT.
* }
const
{$EXTERNALSYM DBT_DEVICEARRIVAL}
DBT_DEVICEARRIVAL = $8000; { system detected a new device }
{$EXTERNALSYM DBT_DEVICEQUERYREMOVE}
DBT_DEVICEQUERYREMOVE = $8001; { wants to remove, may fail }
{$EXTERNALSYM DBT_DEVICEQUERYREMOVEFAILED}
DBT_DEVICEQUERYREMOVEFAILED = $8002; { removal aborted }
{$EXTERNALSYM DBT_DEVICEREMOVEPENDING}
DBT_DEVICEREMOVEPENDING = $8003; { about to remove, still avail. }
{$EXTERNALSYM DBT_DEVICEREMOVECOMPLETE}
DBT_DEVICEREMOVECOMPLETE = $8004; { device is gone }
{$EXTERNALSYM DBT_DEVICETYPESPECIFIC}
DBT_DEVICETYPESPECIFIC = $8005; { type specific event }
{$EXTERNALSYM DBT_CUSTOMEVENT}
DBT_CUSTOMEVENT = $8006; { user-defined event }
{$EXTERNALSYM DBT_DEVTYP_OEM}
DBT_DEVTYP_OEM = $00000000; { oem-defined device type }
{$EXTERNALSYM DBT_DEVTYP_DEVNODE}
DBT_DEVTYP_DEVNODE = $00000001; { devnode number }
{$EXTERNALSYM DBT_DEVTYP_VOLUME}
DBT_DEVTYP_VOLUME = $00000002; { logical volume }
{$EXTERNALSYM DBT_DEVTYP_PORT}
DBT_DEVTYP_PORT = $00000003; { serial, parallel }
{$EXTERNALSYM DBT_DEVTYP_NET}
DBT_DEVTYP_NET = $00000004; { network resource }
{$EXTERNALSYM DBT_DEVTYP_DEVICEINTERFACE}
DBT_DEVTYP_DEVICEINTERFACE = $00000005; { device interface class }
{$EXTERNALSYM DBT_DEVTYP_HANDLE}
DBT_DEVTYP_HANDLE = $00000006; { file system handle }
type
{$EXTERNALSYM _DEV_BROADCAST_HEADER}
_DEV_BROADCAST_HEADER = packed record
dbcd_size: DWORD;
dbcd_devicetype: DWORD;
dbcd_reserved: DWORD;
end;
TDevBroadcastHeader = _DEV_BROADCAST_HEADER;
PDevBroadcastOem = ^TDevBroadcastOem;
{$EXTERNALSYM _DEV_BROADCAST_OEM}
_DEV_BROADCAST_OEM = packed record
dbco_size: DWORD;
dbco_devicetype: DWORD;
dbco_reserved: DWORD;
dbco_identifier: DWORD;
dbco_suppfunc: DWORD;
end;
TDevBroadcastOem = _DEV_BROADCAST_OEM;
{$EXTERNALSYM DEV_BROADCAST_OEM}
DEV_BROADCAST_OEM = _DEV_BROADCAST_OEM;
PDevBroadcastDevNode = ^TDevBroadcastDevNode;
{$EXTERNALSYM _DEV_BROADCAST_DEVNODE}
_DEV_BROADCAST_DEVNODE = packed record
dbcd_size: DWORD;
dbcd_devicetype: DWORD;
dbcd_reserved: DWORD;
dbcd_devnode: DWORD;
end;
TDevBroadcastDevNode = _DEV_BROADCAST_DEVNODE;
{$EXTERNALSYM DEV_BROADCAST_DEVNODE}
DEV_BROADCAST_DEVNODE = _DEV_BROADCAST_DEVNODE;
PDevBroadcastVolume = ^TDevBroadcastVolume;
{$EXTERNALSYM _DEV_BROADCAST_VOLUME}
_DEV_BROADCAST_VOLUME = packed record
dbcv_size: DWORD;
dbcv_devicetype: DWORD;
dbcv_reserved: DWORD;
dbcv_unitmask: DWORD;
dbcv_flags: Word;
end;
TDevBroadcastVolume = _DEV_BROADCAST_VOLUME;
{$EXTERNALSYM DEV_BROADCAST_VOLUME}
DEV_BROADCAST_VOLUME = _DEV_BROADCAST_VOLUME;
const
{$EXTERNALSYM DBTF_MEDIA}
DBTF_MEDIA = $0001; { media commings and goings }
{$EXTERNALSYM DBTF_NET}
DBTF_NET = $0002; { network volume }
type
PDevBroadCastPortA = ^TDevBroadCastPortA;
{$EXTERNALSYM _DEV_BROADCAST_PORT_A}
_DEV_BROADCAST_PORT_A = packed record
dbcp_size: DWORD;
dbcp_devicetype: DWORD;
dbcp_reserved: DWORD;
dbcp_name: array[0..0] of AnsiChar;
end;
TDevBroadCastPortA = _DEV_BROADCAST_PORT_A;
{$EXTERNALSYM DEV_BROADCAST_PORT_A}
DEV_BROADCAST_PORT_A = _DEV_BROADCAST_PORT_A;
PDevBroadCastPortW = ^TDevBroadCastPortW;
{$EXTERNALSYM _DEV_BROADCAST_PORT_W}
_DEV_BROADCAST_PORT_W = packed record
dbcp_size: DWORD;
dbcp_devicetype: DWORD;
dbcp_reserved: DWORD;
dbcp_name: array[0..0] of WideChar;
end;
TDevBroadCastPortW = _DEV_BROADCAST_PORT_W;
{$EXTERNALSYM DEV_BROADCAST_PORT_W}
DEV_BROADCAST_PORT_W = _DEV_BROADCAST_PORT_W;
PDevBroadCastPort = PDevBroadCastPortA;
type
PDevBroadcastNet = ^TDevBroadcastNet;
{$EXTERNALSYM _DEV_BROADCAST_NET}
_DEV_BROADCAST_NET = packed record
dbcn_size: DWORD;
dbcn_devicetype: DWORD;
dbcn_reserved: DWORD;
dbcn_resource: DWORD;
dbcn_flags: DWORD;
end;
TDevBroadcastNet = _DEV_BROADCAST_NET;
{$EXTERNALSYM DEV_BROADCAST_NET}
DEV_BROADCAST_NET = _DEV_BROADCAST_NET;
PDevBroadcastDeviceInterfaceA = ^TDevBroadcastDeviceInterfaceA;
{$EXTERNALSYM _DEV_BROADCAST_DEVICEINTERFACE_A}
_DEV_BROADCAST_DEVICEINTERFACE_A = packed record
dbcc_size: DWORD;
dbcc_devicetype: DWORD;
dbcc_reserved: DWORD;
dbcc_classguid: TGUID;
dbcc_name: Array[0..0] of AnsiChar;
end;
TDevBroadcastDeviceInterfaceA = _DEV_BROADCAST_DEVICEINTERFACE_A;
{$EXTERNALSYM DEV_BROADCAST_DEVICEINTERFACE_A}
DEV_BROADCAST_DEVICEINTERFACE_A = _DEV_BROADCAST_DEVICEINTERFACE_A;
PDevBroadcastDeviceInterfaceW = ^TDevBroadcastDeviceInterfaceW;
{$EXTERNALSYM _DEV_BROADCAST_DEVICEINTERFACE_W}
_DEV_BROADCAST_DEVICEINTERFACE_W = packed record
dbcc_size: DWORD;
dbcc_devicetype: DWORD;
dbcc_reserved: DWORD;
dbcc_classguid: TGUID;
dbcc_name: Array[0..0] of WideChar;
end;
TDevBroadcastDeviceInterfaceW = _DEV_BROADCAST_DEVICEINTERFACE_W;
{$EXTERNALSYM DEV_BROADCAST_DEVICEINTERFACE_W}
DEV_BROADCAST_DEVICEINTERFACE_W = _DEV_BROADCAST_DEVICEINTERFACE_W;
PDevBroadcastDeviceInterface = PDevBroadcastDeviceInterfaceA;
{$EXTERNALSYM _DEV_BROADCAST_HANDLE}
PDevBroadcastHandle = ^TDevBroadcastHandle;
_DEV_BROADCAST_HANDLE = packed record
dbch_size: DWORD;
dbch_devicetype: DWORD;
dbch_reserved: DWORD;
dbch_handle: THandle; { file handle used in call to RegisterDeviceNotification }
dbch_hdevnotify: DWORD; { HDEVNOTIFY returned from RegisterDeviceNotification }
{ The following 3 fields are only valid if wParam is DBT_CUSTOMEVENT. }
dbch_eventguid: TGUID;
dbch_nameoffset: DWORD; { offset (bytes) of variable-length string buffer (-1 if none)}
dbch_data: Array[0..0] of BYTE; { variable-sized buffer, potentially containing binary and/or text data }
end;
TDevBroadcastHandle = _DEV_BROADCAST_HANDLE;
{$EXTERNALSYM DEV_BROADCAST_HANDLE}
DEV_BROADCAST_HANDLE = _DEV_BROADCAST_HANDLE;
const
{$EXTERNALSYM DBTF_RESOURCE}
DBTF_RESOURCE = $00000001; { network resource }
{$EXTERNALSYM DBTF_XPORT}
DBTF_XPORT = $00000002; { new transport coming or going }
{$EXTERNALSYM DBTF_SLOWNET}
DBTF_SLOWNET = $00000004; { new incoming transport is slow }
{ (dbcn_resource undefined for now) }
{$EXTERNALSYM DBT_VPOWERDAPI}
DBT_VPOWERDAPI = $8100; { VPOWERD API for Win95 }
{ *
* User-defined message types all use wParam = 0xFFFF with the
* lParam a pointer to the structure below.
*
* dbud_dbh - DEV_BROADCAST_HEADER must be filled in as usual.
*
* dbud_szName contains a case-sensitive ASCIIZ name which names the
* message. The message name consists of the vendor name, a backslash,
* then arbitrary user-defined ASCIIZ text. For example:
*
* "WidgetWare\QueryScannerShutdown"
* "WidgetWare\Video Q39S\AdapterReady"
*
* After the ASCIIZ name, arbitrary information may be provided.
* Make sure that dbud_dbh.dbch_size is big enough to encompass
* all the data. And remember that nothing in the structure may
* contain pointers.
* }
const
{$EXTERNALSYM DBT_USERDEFINED}
DBT_USERDEFINED = $FFF;
type
{$EXTERNALSYM _DEV_BROADCAST_USERDEFINED}
_DEV_BROADCAST_USERDEFINED = packed record
dbud_dbh: TDevBroadcastHdr;
dbud_szName: Array[0..0] of Char; { ASCIIZ name }
{dbud_rgbUserDefined[]: Byte; // User-defined contents }
end;
{ added own message type for WM_DEVICECHANGE }
type
TWMDeviceChange = record
Msg: Cardinal;
Event: UINT;
dwData: Pointer;
Result: LongInt;
end;
implementation
end.