1 {******************************************************************************}
2 { }
3 { Disk Quota's API interface Unit for Object Pascal }
4 { }
5 { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
6 { Corporation. All Rights Reserved. }
7 { }
8 { The original file is: dskquota.h, released June 2000. The original Pascal }
9 { code is: DskQuota.pas, released December 2000. The initial developer of the }
10 { Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
11 { }
12 { Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
13 { Marcel van Brakel. All Rights Reserved. }
14 { }
15 { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
16 { }
17 { You may retrieve the latest version of this file at the Project JEDI }
18 { APILIB home page, located at http://jedi-apilib.sourceforge.net }
19 { }
20 { The contents of this file are used with permission, subject to the Mozilla }
21 { Public License Version 1.1 (the "License"); you may not use this file except }
22 { in compliance with the License. You may obtain a copy of the License at }
23 { http://www.mozilla.org/MPL/MPL-1.1.html }
24 { }
25 { Software distributed under the License is distributed on an "AS IS" basis, }
26 { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27 { the specific language governing rights and limitations under the License. }
28 { }
29 { Alternatively, the contents of this file may be used under the terms of the }
30 { GNU Lesser General Public License (the "LGPL License"), in which case the }
31 { provisions of the LGPL License are applicable instead of those above. }
32 { If you wish to allow use of your version of this file only under the terms }
33 { of the LGPL License and not to allow others to use your version of this file }
34 { under the MPL, indicate your decision by deleting the provisions above and }
35 { replace them with the notice and other provisions required by the LGPL }
36 { License. If you do not delete the provisions above, a recipient may use }
37 { your version of this file under either the MPL or the LGPL License. }
38 { }
39 { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
40 { }
41 {******************************************************************************}
42
43 // $Id: JwaDskQuota.pas,v 1.9 2007/09/05 11:58:49 dezipaitor Exp $
44 {$IFNDEF JWA_OMIT_SECTIONS}
45 unit JwaDskQuota;
46
47 {$WEAKPACKAGEUNIT}
48 {$ENDIF JWA_OMIT_SECTIONS}
49
50 {$HPPEMIT ''}
51 {$HPPEMIT '#include "DskQuota.h"'}
52 {$HPPEMIT ''}
53
54 {$IFNDEF JWA_OMIT_SECTIONS}
55 {$I jediapilib.inc}
56
57 interface
58
59 uses
60 JwaActiveX, JwaWinNT, JwaWinType;
61
62 {$ENDIF JWA_OMIT_SECTIONS}
63
64 {$IFNDEF JWA_IMPLEMENTATIONSECTION}
65
66 const
67
68 //
69 // Class IDs
70 //
71 // {7988B571-EC89-11cf-9C00-00AA00A14F56}
72
73 CLSID_DiskQuotaControl: TGUID = (
74 D1:$7988b571; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
75 {$EXTERNALSYM CLSID_DiskQuotaControl}
76
77 //
78 // Interface IDs
79 //
80 // {7988B572-EC89-11cf-9C00-00AA00A14F56}
81
82 IID_IDiskQuotaControl: TGUID = (
83 D1:$7988b572; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
84 {$EXTERNALSYM IID_IDiskQuotaControl}
85
86 // {7988B574-EC89-11cf-9C00-00AA00A14F56}
87
88 IID_IDiskQuotaUser: TGUID = (
89 D1:$7988b574; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
90 {$EXTERNALSYM IID_IDiskQuotaUser}
91
92 // {7988B576-EC89-11cf-9C00-00AA00A14F56}
93
94 IID_IDiskQuotaUserBatch: TGUID = (
95 D1:$7988b576; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
96 {$EXTERNALSYM IID_IDiskQuotaUserBatch}
97
98 // {7988B577-EC89-11cf-9C00-00AA00A14F56}
99
100 IID_IEnumDiskQuotaUsers: TGUID = (
101 D1:$7988b577; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
102 {$EXTERNALSYM IID_IEnumDiskQuotaUsers}
103
104 // {7988B579-EC89-11cf-9C00-00AA00A14F56}
105
106 IID_IDiskQuotaEvents: TGUID = (
107 D1:$7988b579; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
108 {$EXTERNALSYM IID_IDiskQuotaEvents}
109
110 //
111 // Definitions for value and bits in DWORD returned by
112 // IDiskQuotaControl::GetQuotaState.
113 //
114
115 DISKQUOTA_STATE_DISABLED = $00000000;
116 {$EXTERNALSYM DISKQUOTA_STATE_DISABLED}
117 DISKQUOTA_STATE_TRACK = $00000001;
118 {$EXTERNALSYM DISKQUOTA_STATE_TRACK}
119 DISKQUOTA_STATE_ENFORCE = $00000002;
120 {$EXTERNALSYM DISKQUOTA_STATE_ENFORCE}
121 DISKQUOTA_STATE_MASK = $00000003;
122 {$EXTERNALSYM DISKQUOTA_STATE_MASK}
123 DISKQUOTA_FILESTATE_INCOMPLETE = $00000100;
124 {$EXTERNALSYM DISKQUOTA_FILESTATE_INCOMPLETE}
125 DISKQUOTA_FILESTATE_REBUILDING = $00000200;
126 {$EXTERNALSYM DISKQUOTA_FILESTATE_REBUILDING}
127 DISKQUOTA_FILESTATE_MASK = $00000300;
128 {$EXTERNALSYM DISKQUOTA_FILESTATE_MASK}
129
130 //
131 // Helper macros for setting and testing state value.
132 //
133
DISKQUOTA_SET_DISABLEDnull134 function DISKQUOTA_SET_DISABLED(var s: DWORD): DWORD;
135 {$EXTERNALSYM DISKQUOTA_SET_DISABLED}
DISKQUOTA_SET_TRACKEDnull136 function DISKQUOTA_SET_TRACKED(var s: DWORD): DWORD;
137 {$EXTERNALSYM DISKQUOTA_SET_TRACKED}
DISKQUOTA_SET_ENFORCEDnull138 function DISKQUOTA_SET_ENFORCED(var s: DWORD): DWORD;
139 {$EXTERNALSYM DISKQUOTA_SET_ENFORCED}
DISKQUOTA_IS_DISABLEDnull140 function DISKQUOTA_IS_DISABLED(s: DWORD): BOOL;
141 {$EXTERNALSYM DISKQUOTA_IS_DISABLED}
DISKQUOTA_IS_TRACKEDnull142 function DISKQUOTA_IS_TRACKED(s: DWORD): BOOL;
143 {$EXTERNALSYM DISKQUOTA_IS_TRACKED}
DISKQUOTA_IS_ENFORCEDnull144 function DISKQUOTA_IS_ENFORCED(s: DWORD): BOOL;
145 {$EXTERNALSYM DISKQUOTA_IS_ENFORCED}
146
147 //
148 // These file state flags are read-only.
149 //
150
DISKQUOTA_FILE_INCOMPLETEnull151 function DISKQUOTA_FILE_INCOMPLETE(s: DWORD): BOOL;
152 {$EXTERNALSYM DISKQUOTA_FILE_INCOMPLETE}
DISKQUOTA_FILE_REBUILDINGnull153 function DISKQUOTA_FILE_REBUILDING(s: DWORD): BOOL;
154 {$EXTERNALSYM DISKQUOTA_FILE_REBUILDING}
155
156 //
157 // Definitions for bits in DWORD returned by
158 // IDiskQuotaControl::GetQuotaLogFlags.
159 //
160
161 const
162 DISKQUOTA_LOGFLAG_USER_THRESHOLD = $00000001;
163 {$EXTERNALSYM DISKQUOTA_LOGFLAG_USER_THRESHOLD}
164 DISKQUOTA_LOGFLAG_USER_LIMIT = $00000002;
165 {$EXTERNALSYM DISKQUOTA_LOGFLAG_USER_LIMIT}
166
167 //
168 // Helper macros to interrogate a log flags DWORD.
169 //
170
DISKQUOTA_IS_LOGGED_USER_THRESHOLDnull171 function DISKQUOTA_IS_LOGGED_USER_THRESHOLD(f: DWORD): BOOL;
172 {$EXTERNALSYM DISKQUOTA_IS_LOGGED_USER_THRESHOLD}
DISKQUOTA_IS_LOGGED_USER_LIMITnull173 function DISKQUOTA_IS_LOGGED_USER_LIMIT(f: DWORD): BOOL;
174 {$EXTERNALSYM DISKQUOTA_IS_LOGGED_USER_LIMIT}
175
176 //
177 // Helper macros to set/clear bits in a log flags DWORD.
178 //
179
DISKQUOTA_SET_LOG_USER_THRESHOLDnull180 function DISKQUOTA_SET_LOG_USER_THRESHOLD(f: DWORD; yn: BOOL): DWORD;
181 {$EXTERNALSYM DISKQUOTA_SET_LOG_USER_THRESHOLD}
DISKQUOTA_SET_LOG_USER_LIMITnull182 function DISKQUOTA_SET_LOG_USER_LIMIT(f: DWORD; yn: BOOL): DWORD;
183 {$EXTERNALSYM DISKQUOTA_SET_LOG_USER_LIMIT}
184
185 //
186 // Per-user quota information.
187 //
188
189 type
190 PDISKQUOTA_USER_INFORMATION = ^DISKQUOTA_USER_INFORMATION;
191 {$EXTERNALSYM PDISKQUOTA_USER_INFORMATION}
192 DiskQuotaUserInformation = record
193 QuotaUsed: LONGLONG;
194 QuotaThreshold: LONGLONG;
195 QuotaLimit: LONGLONG;
196 end;
197 {$EXTERNALSYM DiskQuotaUserInformation}
198 DISKQUOTA_USER_INFORMATION = DiskQuotaUserInformation;
199 {$EXTERNALSYM DISKQUOTA_USER_INFORMATION}
200 TDiskQuotaUserInformation = DISKQUOTA_USER_INFORMATION;
201 PDiskQuotaUserInformation = PDISKQUOTA_USER_INFORMATION;
202
203 //
204 // Values for fNameResolution argument to:
205 //
206 // IDiskQuotaControl::AddUserSid
207 // IDiskQuotaControl::AddUserName
208 // IDiskQuotaControl::FindUserSid
209 // IDiskQuotaControl::CreateEnumUsers
210 //
211
212 const
213 DISKQUOTA_USERNAME_RESOLVE_NONE = 0;
214 {$EXTERNALSYM DISKQUOTA_USERNAME_RESOLVE_NONE}
215 DISKQUOTA_USERNAME_RESOLVE_SYNC = 1;
216 {$EXTERNALSYM DISKQUOTA_USERNAME_RESOLVE_SYNC}
217 DISKQUOTA_USERNAME_RESOLVE_ASYNC = 2;
218 {$EXTERNALSYM DISKQUOTA_USERNAME_RESOLVE_ASYNC}
219
220 //
221 // Values for status returned by IDiskQuotaUser::GetAccountStatus.
222 //
223
224 DISKQUOTA_USER_ACCOUNT_RESOLVED = 0;
225 {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_RESOLVED}
226 DISKQUOTA_USER_ACCOUNT_UNAVAILABLE = 1;
227 {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_UNAVAILABLE}
228 DISKQUOTA_USER_ACCOUNT_DELETED = 2;
229 {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_DELETED}
230 DISKQUOTA_USER_ACCOUNT_INVALID = 3;
231 {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_INVALID}
232 DISKQUOTA_USER_ACCOUNT_UNKNOWN = 4;
233 {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_UNKNOWN}
234 DISKQUOTA_USER_ACCOUNT_UNRESOLVED = 5;
235 {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_UNRESOLVED}
236
237 //
238 // IDiskQuotaUser represents a single user quota record on a particular
239 // NTFS volume. Objects using this interface are instantiated
240 // through several IDiskQuotaControl methods.
241 //
242
243 type
244 IDiskQuotaUser = interface (IUnknown)
245 ['{7988B574-EC89-11cf-9C00-00AA00A14F56}']
GetIDnull246 function GetID(var pulID: ULONG): HRESULT; stdcall;
GetNamenull247 function GetName(pszAccountContainer: LPWSTR; cchAccountContainer: DWORD;
248 pszLogonName: LPWSTR; cchLogonName: DWORD; pszDisplayName: LPWSTR;
249 cchDisplayName: DWORD): HRESULT; stdcall;
GetSidLengthnull250 function GetSidLength(var pdwLength: DWORD): HRESULT; stdcall;
GetSidnull251 function GetSid(pbSidBuffer: LPBYTE; cbSidBuffer: DWORD): HRESULT; stdcall;
GetQuotaThresholdnull252 function GetQuotaThreshold(var pllThreshold: LONGLONG): HRESULT; stdcall;
GetQuotaThresholdTextnull253 function GetQuotaThresholdText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
GetQuotaLimitnull254 function GetQuotaLimit(var pllLimit: LONGLONG): HRESULT; stdcall;
GetQuotaLimitTextnull255 function GetQuotaLimitText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
GetQuotaUsednull256 function GetQuotaUsed(var pllUsed: LONGLONG): HRESULT; stdcall;
GetQuotaUsedTextnull257 function GetQuotaUsedText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
GetQuotaInformationnull258 function GetQuotaInformation(pbQuotaInfo: LPVOID; cbQuotaInfo: DWORD): HRESULT; stdcall;
SetQuotaThresholdnull259 function SetQuotaThreshold(llThreshold: LONGLONG; fWriteThrough: BOOL): HRESULT; stdcall;
SetQuotaLimitnull260 function SetQuotaLimit(llLimit: LONGLONG; fWriteThrough: BOOL): HRESULT; stdcall;
Invalidatenull261 function Invalidate: HRESULT; stdcall;
GetAccountStatusnull262 function GetAccountStatus(var pdwStatus: DWORD): HRESULT; stdcall;
263 end;
264 {$EXTERNALSYM IDiskQuotaUser}
265
266 DISKQUOTA_USER = IDiskQuotaUser;
267 {$EXTERNALSYM DISKQUOTA_USER}
268 PDISKQUOTA_USER = ^DISKQUOTA_USER;
269 {$EXTERNALSYM PDISKQUOTA_USER}
270
271 //
272 // IEnumDiskQuotaUsers represents an enumerator created by
273 // IDiskQuotaControl for the purpose of enumerating individual user quota
274 // records on a particular volume. Each record is represented through
275 // the IDiskQuotaUser interface.
276 //
277
278 IEnumDiskQuotaUsers = interface (IUnknown)
279 ['{7988B577-EC89-11cf-9C00-00AA00A14F56}']
Nextnull280 function Next(cUsers: DWORD; var rgUsers: IDiskQuotaUser; pcUsersFetched: LPDWORD): HRESULT; stdcall;
Skipnull281 function Skip(cUsers: DWORD): HRESULT; stdcall;
Resetnull282 function Reset: HRESULT; stdcall;
Clonenull283 function Clone(out ppEnum: IEnumDiskQuotaUsers): HRESULT; stdcall;
284 end;
285 {$EXTERNALSYM IEnumDiskQuotaUsers}
286
287 ENUM_DISKQUOTA_USERS = IEnumDiskQuotaUsers;
288 {$EXTERNALSYM ENUM_DISKQUOTA_USERS}
289 PENUM_DISKQUOTA_USERS = ^ENUM_DISKQUOTA_USERS;
290 {$EXTERNALSYM PENUM_DISKQUOTA_USERS}
291
292 //
293 // IDiskQuotaUserBatch represents a collection of IDiskQuotaUser
294 // pointers for the purpose of grouping updates to quota information.
295 //
296
297 IDiskQuotaUserBatch = interface (IUnknown)
298 ['{7988B576-EC89-11cf-9C00-00AA00A14F56}']
Addnull299 function Add(pUser: IDiskQuotaUser): HRESULT; stdcall;
Removenull300 function Remove(pUser: IDiskQuotaUser): HRESULT; stdcall;
RemoveAllnull301 function RemoveAll: HRESULT; stdcall;
FlushToDisknull302 function FlushToDisk: HRESULT; stdcall;
303 end;
304 {$EXTERNALSYM IDiskQuotaUserBatch}
305
306 DISKQUOTA_USER_BATCH = IDiskQuotaUserBatch;
307 {$EXTERNALSYM DISKQUOTA_USER_BATCH}
308 PDISKQUOTA_USER_BATCH = ^DISKQUOTA_USER_BATCH;
309 {$EXTERNALSYM PDISKQUOTA_USER_BATCH}
310
311 //
312 // IDiskQuotaControl represents a disk volume, providing query and
313 // control of that volume's quota information.
314 //
315
316 IDiskQuotaControl = interface (IConnectionPointContainer)
317 ['{7988B571-EC89-11cf-9C00-00AA00A14F56}']
318 function Initialize(pszPath: LPCWSTR; bReadWrite: BOOL): HRESULT; stdcall;
319 function SetQuotaState(dwState: DWORD): HRESULT; stdcall;
320 function GetQuotaState(var pdwState: DWORD): HRESULT; stdcall;
321 function SetQuotaLogFlags(dwFlags: DWORD): HRESULT; stdcall;
322 function GetQuotaLogFlags(var pdwFlags: DWORD): HRESULT; stdcall;
323 function SetDefaultQuotaThreshold(llThreshold: LONGLONG): HRESULT; stdcall;
324 function GetDefaultQuotaThreshold(var pllThreshold: LONGLONG): HRESULT; stdcall;
325 function GetDefaultQuotaThresholdText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
326 function SetDefaultQuotaLimit(llLimit: LONGLONG): HRESULT; stdcall;
327 function GetDefaultQuotaLimit(var pllLimit: LONGLONG): HRESULT; stdcall;
328 function GetDefaultQuotaLimitText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
329 function AddUserSid(pUserSid: PSID; fNameResolution: DWORD;
330 out ppUser: IDiskQuotaUser): HRESULT; stdcall;
331 function AddUserName(pszLogonName: LPCWSTR; fNameResolution: DWORD;
332 out ppUser: IDiskQuotaUser): HRESULT; stdcall;
333 function DeleteUser(pUser: IDiskQuotaUser): HRESULT; stdcall;
334 function FindUserSid(pUserSid: PSID; fNameResolution: DWORD;
335 out ppUser: IDiskQuotaUser): HRESULT; stdcall;
336 function FindUserName(pszLogonName: LPCWSTR; out ppUser: IDiskQuotaUser): HRESULT; stdcall;
337 function CreateEnumUsers(rgpUserSids: PSID; cpSids, fNameResolution: DWORD;
338 out ppEnum: IEnumDiskQuotaUsers): HRESULT; stdcall;
339 function CreateUserBatch(out ppBatch: IDiskQuotaUserBatch): HRESULT; stdcall;
340 function InvalidateSidNameCache: HRESULT; stdcall;
341 function GiveUserNameResolutionPriority(pUser: IDiskQuotaUser): HRESULT; stdcall;
342 function ShutdownNameResolution: HRESULT; stdcall;
343 end;
344 {$EXTERNALSYM IDiskQuotaControl}
345
346 DISKQUOTA_CONTROL = IDiskQuotaControl;
347 {$EXTERNALSYM DISKQUOTA_CONTROL}
348 PDISKQUOTA_CONTROL = ^DISKQUOTA_CONTROL;
349 {$EXTERNALSYM PDISKQUOTA_CONTROL}
350
351 IDiskQuotaEvents = interface (IUnknown)
352 ['{7988B579-EC89-11cf-9C00-00AA00A14F56}']
353 function OnUserNameChanged(pUser: IDiskQuotaUser): HRESULT; stdcall;
354 end;
355 {$EXTERNALSYM IDiskQuotaEvents}
356
357 DISKQUOTA_EVENTS = IDiskQuotaEvents;
358 {$EXTERNALSYM DISKQUOTA_EVENTS;}
359 PDISKQUOTA_EVENTS = ^DISKQUOTA_EVENTS;
360 {$EXTERNALSYM PDISKQUOTA_EVENTS;}
361 {$ENDIF JWA_IMPLEMENTATIONSECTION}
362
363 {$IFNDEF JWA_OMIT_SECTIONS}
364 implementation
365 //uses ...
366 {$ENDIF JWA_OMIT_SECTIONS}
367
368
369 {$IFNDEF JWA_INTERFACESECTION}
370
371 function DISKQUOTA_SET_DISABLED(var s: DWORD): DWORD;
372 begin
373 s := DISKQUOTA_STATE_DISABLED;
374 Result := s;
375 end;
376
377 function DISKQUOTA_SET_TRACKED(var s: DWORD): DWORD;
378 begin
379 s := DISKQUOTA_STATE_TRACK;
380 Result := s;
381 end;
382
383 function DISKQUOTA_SET_ENFORCED(var s: DWORD): DWORD;
384 begin
385 s := DISKQUOTA_STATE_ENFORCE;
386 Result := s;
387 end;
388
389 function DISKQUOTA_IS_DISABLED(s: DWORD): BOOL;
390 begin
391 Result := (DISKQUOTA_STATE_DISABLED = (s and DISKQUOTA_STATE_MASK));
392 end;
393
394 function DISKQUOTA_IS_TRACKED(s: DWORD): BOOL;
395 begin
396 Result := (DISKQUOTA_STATE_TRACK = (s and DISKQUOTA_STATE_MASK));
397 end;
398
399 function DISKQUOTA_IS_ENFORCED(s: DWORD): BOOL;
400 begin
401 Result := (DISKQUOTA_STATE_ENFORCE = (s and DISKQUOTA_STATE_MASK));
402 end;
403
404 function DISKQUOTA_FILE_INCOMPLETE(s: DWORD): BOOL;
405 begin
406 Result := (0 <> (s and DISKQUOTA_FILESTATE_INCOMPLETE));
407 end;
408
409 function DISKQUOTA_FILE_REBUILDING(s: DWORD): BOOL;
410 begin
411 Result := (0 <> (s and DISKQUOTA_FILESTATE_REBUILDING));
412 end;
413
414 function DISKQUOTA_IS_LOGGED_USER_THRESHOLD(f: DWORD): BOOL;
415 begin
416 Result := (0 <> (f and DISKQUOTA_LOGFLAG_USER_THRESHOLD));
417 end;
418
419 function DISKQUOTA_IS_LOGGED_USER_LIMIT(f: DWORD): BOOL;
420 begin
421 Result := (0 <> (f and DISKQUOTA_LOGFLAG_USER_LIMIT));
422 end;
423
424 function DISKQUOTA_SET_LOG_USER_THRESHOLD(f: DWORD; yn: BOOL): DWORD;
425 begin
426 Result := f and (not DISKQUOTA_LOGFLAG_USER_THRESHOLD);
427 if yn then
428 Result := Result or DISKQUOTA_LOGFLAG_USER_THRESHOLD;
429 end;
430
431 function DISKQUOTA_SET_LOG_USER_LIMIT(f: DWORD; yn: BOOL): DWORD;
432 begin
433 Result := f and (not DISKQUOTA_LOGFLAG_USER_LIMIT);
434 if yn then
435 Result := Result or DISKQUOTA_LOGFLAG_USER_LIMIT;
436 end;
437
438 {$ENDIF JWA_INTERFACESECTION}
439
440
441 {$IFNDEF JWA_OMIT_SECTIONS}
442 end.
443 {$ENDIF JWA_OMIT_SECTIONS}
444