1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/**
* Windows API header module
*
* Translated from MinGW Windows headers
*
* Authors: Vladimir Vlasov
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(DRUNTIMESRC core/sys/windows/_dbt.d)
*/
module core.sys.windows.dbt;
version (Windows):
@system:
version (ANSI) {} else version = Unicode;
import core.sys.windows.w32api, core.sys.windows.windef;
import core.sys.windows.basetyps; // for GUID
// FIXME: clean up Windows version support
enum : DWORD {
DBT_NO_DISK_SPACE = 0x47,
DBT_CONFIGMGPRIVATE = 0x7FFF,
DBT_DEVICEARRIVAL = 0x8000,
DBT_DEVICEQUERYREMOVE = 0x8001,
DBT_DEVICEQUERYREMOVEFAILED = 0x8002,
DBT_DEVICEREMOVEPENDING = 0x8003,
DBT_DEVICEREMOVECOMPLETE = 0x8004,
DBT_DEVICETYPESPECIFIC = 0x8005,
DBT_DEVTYP_OEM = 0,
DBT_DEVTYP_DEVNODE,
DBT_DEVTYP_VOLUME,
DBT_DEVTYP_PORT,
DBT_DEVTYP_NET,
DBT_DEVTYP_DEVICEINTERFACE,
DBT_DEVTYP_HANDLE // = 6
}
enum : DWORD {
DBT_APPYBEGIN,
DBT_APPYEND,
DBT_DEVNODES_CHANGED = 7,
DBT_QUERYCHANGECONFIG = 0x17,
DBT_CONFIGCHANGED = 0x18,
DBT_CONFIGCHANGECANCELED = 0x19,
DBT_MONITORCHANGE = 0x1B,
DBT_SHELLLOGGEDON = 32,
DBT_CONFIGMGAPI32 = 34,
DBT_VXDINITCOMPLETE = 35,
DBT_VOLLOCKQUERYLOCK = 0x8041,
DBT_VOLLOCKLOCKTAKEN = 0x8042,
DBT_VOLLOCKLOCKFAILED = 0x8043,
DBT_VOLLOCKQUERYUNLOCK = 0x8044,
DBT_VOLLOCKLOCKRELEASED = 0x8045,
DBT_VOLLOCKUNLOCKFAILED = 0x8046,
DBT_USERDEFINED = 0xFFFF
}
enum : WORD {
DBTF_MEDIA = 1,
DBTF_NET = 2
}
enum : DWORD {
BSM_ALLCOMPONENTS = 0,
BSM_APPLICATIONS = 8,
BSM_ALLDESKTOPS = 16,
BSM_INSTALLABLEDRIVERS = 4,
BSM_NETDRIVER = 2,
BSM_VXDS = 1,
BSF_FLUSHDISK = 0x00000004,
BSF_FORCEIFHUNG = 0x00000020,
BSF_IGNORECURRENTTASK = 0x00000002,
BSF_NOHANG = 0x00000008,
BSF_NOTIMEOUTIFNOTHUNG = 0x00000040,
BSF_POSTMESSAGE = 0x00000010,
BSF_QUERY = 0x00000001,
BSF_MSGSRV32ISOK_BIT = 31,
BSF_MSGSRV32ISOK = 0x80000000
}
//static if (_WIN32_WINNT >= 0x500) {
enum : DWORD {
BSF_ALLOWSFW = 0x00000080,
BSF_SENDNOTIFYMESSAGE = 0x00000100
}
//}
static if (_WIN32_WINNT >= 0x501) {
enum : DWORD {
BSF_LUID = 0x00000400,
BSF_RETURNHDESK = 0x00000200
}
}
struct DEV_BROADCAST_HDR {
DWORD dbch_size = DEV_BROADCAST_HDR.sizeof;
DWORD dbch_devicetype;
DWORD dbch_reserved;
}
alias DEV_BROADCAST_HDR* PDEV_BROADCAST_HDR;
struct DEV_BROADCAST_OEM {
DWORD dbco_size = DEV_BROADCAST_OEM.sizeof;
DWORD dbco_devicetype;
DWORD dbco_reserved;
DWORD dbco_identifier;
DWORD dbco_suppfunc;
}
alias DEV_BROADCAST_OEM* PDEV_BROADCAST_OEM;
struct DEV_BROADCAST_PORT_A {
DWORD dbcp_size = DEV_BROADCAST_PORT_A.sizeof;
DWORD dbcp_devicetype;
DWORD dbcp_reserved;
char _dbcp_name = 0;
char* dbcp_name() return { return &_dbcp_name; }
}
alias DEV_BROADCAST_PORT_A* PDEV_BROADCAST_PORT_A;
struct DEV_BROADCAST_PORT_W {
DWORD dbcp_size = DEV_BROADCAST_PORT_W.sizeof;
DWORD dbcp_devicetype;
DWORD dbcp_reserved;
WCHAR _dbcp_name = 0;
WCHAR* dbcp_name() return { return &_dbcp_name; }
}
alias DEV_BROADCAST_PORT_W* PDEV_BROADCAST_PORT_W;
struct DEV_BROADCAST_USERDEFINED {
DEV_BROADCAST_HDR dbud_dbh;
char _dbud_szName = 0;
char* dbud_szName() return { return &_dbud_szName; }
}
struct DEV_BROADCAST_VOLUME {
DWORD dbcv_size = DEV_BROADCAST_VOLUME.sizeof;
DWORD dbcv_devicetype;
DWORD dbcv_reserved;
DWORD dbcv_unitmask;
WORD dbcv_flags;
}
alias DEV_BROADCAST_VOLUME* PDEV_BROADCAST_VOLUME;
version (Unicode) {
alias DEV_BROADCAST_PORT_W DEV_BROADCAST_PORT;
} else {
alias DEV_BROADCAST_PORT_A DEV_BROADCAST_PORT;
}
alias DEV_BROADCAST_PORT* PDEV_BROADCAST_PORT;
//static if (_WIN32_WINNT >= 0x500) {
struct DEV_BROADCAST_DEVICEINTERFACE_A {
DWORD dbcc_size = DEV_BROADCAST_DEVICEINTERFACE_A.sizeof;
DWORD dbcc_devicetype;
DWORD dbcc_reserved;
GUID dbcc_classguid;
char _dbcc_name;
char* dbcc_name() return { return &_dbcc_name; }
}
alias DEV_BROADCAST_DEVICEINTERFACE_A* PDEV_BROADCAST_DEVICEINTERFACE_A;
struct DEV_BROADCAST_DEVICEINTERFACE_W {
DWORD dbcc_size = DEV_BROADCAST_DEVICEINTERFACE_W.sizeof;
DWORD dbcc_devicetype;
DWORD dbcc_reserved;
GUID dbcc_classguid;
WCHAR _dbcc_name = 0;
WCHAR* dbcc_name() return { return &_dbcc_name; }
}
alias DEV_BROADCAST_DEVICEINTERFACE_W* PDEV_BROADCAST_DEVICEINTERFACE_W;
version (Unicode) {
alias DEV_BROADCAST_DEVICEINTERFACE_W DEV_BROADCAST_DEVICEINTERFACE;
} else {
alias DEV_BROADCAST_DEVICEINTERFACE_A DEV_BROADCAST_DEVICEINTERFACE;
}
alias DEV_BROADCAST_DEVICEINTERFACE* PDEV_BROADCAST_DEVICEINTERFACE;
struct DEV_BROADCAST_HANDLE {
DWORD dbch_size = DEV_BROADCAST_HANDLE.sizeof;
DWORD dbch_devicetype;
DWORD dbch_reserved;
HANDLE dbch_handle;
DWORD dbch_hdevnotify;
GUID dbch_eventguid;
LONG dbch_nameoffset;
BYTE _dbch_data;
BYTE* dbch_data() return { return &_dbch_data; }
}
alias DEV_BROADCAST_HANDLE* PDEV_BROADCAST_HANDLE;
//}
|
