dbt.pas

human interface devices.zip 一套组件

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
  PDevBroadcastHeader = ^TDevBroadcastHeader;
  // no EXTERNALSYM because this struct is not declared as C type
  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;

  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;

  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;

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;
  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;
  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;

  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;
  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;
  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;

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
  PDevBroadcastUserdefined = ^TDevBroadcastUserdefined;
  // no EXTERNALSYM because this struct is not declared as C type
  DEV_BROADCAST_USERDEFINED = packed record
    dbud_dbh: TDevBroadcastHdr;
    dbud_szName: Array[0..0] of Char; { ASCIIZ name }
   {dbud_rgbUserDefined[]: Byte; // User-defined contents }
  end;
  TDevBroadcastUserdefined = DEV_BROADCAST_USERDEFINED;

{ added own message type for WM_DEVICECHANGE }

type
  TWMDeviceChange = record
   Msg:    Cardinal;
   Event:  UINT;
   dwData: Pointer;
   Result: LongInt;
  end;

implementation

end.