← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to rtl/win32/wininc/base.inc

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
rtl/win32/wininc/base.inc
1
 
{
2
 
    $Id: base.inc,v 1.21 2003/12/08 21:23:24 peter Exp $
3
 
    This file is part of the Free Pascal run time library.
4
 
    This unit contains base definition for the Win32 API
5
 
    Copyright (c) 1999-2000 by Florian Klaempfl,
6
 
    member of the Free Pascal development team.
7
 
 
8
 
    See the file COPYING.FPC, included in this distribution,
9
 
    for details about the copyright.
10
 
 
11
 
    This program is distributed in the hope that it will be useful,
12
 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14
 
 
15
 
 **********************************************************************}
16
 
 
17
 
{
18
 
  Base.h
19
 
 
20
 
  Base definitions
21
 
 
22
 
  Copyright (C) 1996, 1997 Free Software Foundation, Inc.
23
 
 
24
 
  Author: Scott Christley <scottc@net-community.com>
25
 
 
26
 
  This file is part of the Windows32 API Library.
27
 
 
28
 
  This library is free software; you can redistribute it and/or
29
 
  modify it under the terms of the GNU Library General Public
30
 
  License as published by the Free Software Foundation; either
31
 
  version 2 of the License, or (at your option) any later version.
32
 
 
33
 
  This library is distributed in the hope that it will be useful,
34
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of
35
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
36
 
  Library General Public License for more details.
37
 
 
38
 
  If you are interested in a warranty or support for this source code,
39
 
  contact Scott Christley <scottc@net-community.com> for more information.
40
 
 
41
 
  You should have received a copy of the GNU Library General Public
42
 
  License along with this library; see the file COPYING.LIB.
43
 
  If not, write to the Free Software Foundation,
44
 
  59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
45
 
}
46
 
 
47
 
{$ifdef read_interface}
48
 
 
49
 
{$PACKRECORDS C}
50
 
 
51
 
  type
52
 
     ATOM = word;
53
 
 
54
 
     WINBOOL = longbool;
55
 
     BOOL = WINBOOL;
56
 
 
57
 
     CALTYPE = cardinal;
58
 
     CALID = cardinal;
59
 
 
60
 
     CCHAR = char;
61
 
 
62
 
     COLORREF = cardinal;
63
 
     TCOLORREF = cardinal;
64
 
 
65
 
     SHORT = integer;
66
 
     WINT  = longint;
67
 
     LONG  = longint;
68
 
     DWORD = cardinal;
69
 
 
70
 
     PINTEGER = ^longint;
71
 
     PBOOL    = ^BOOL;
72
 
 
73
 
     LONGLONG  = int64;
74
 
     PLONGLONG = ^LONGLONG;
75
 
 
76
 
     DWORDLONG  = qword;  { was unsigned long  }
77
 
     PDWORDLONG = ^DWORDLONG;
78
 
 
79
 
     HANDLE = System.THandle;
80
 
     HRESULT = System.HResult;
81
 
 
82
 
     HACCEL = HANDLE;
83
 
     HBITMAP = HANDLE;
84
 
     HBRUSH = HANDLE;
85
 
     HCOLORSPACE = HANDLE;
86
 
     HCONV = HANDLE;
87
 
     HCONVLIST = HANDLE;
88
 
     HCURSOR = HANDLE;
89
 
     HDBC = HANDLE;
90
 
     HDC = HANDLE;
91
 
     HDDEDATA = HANDLE;
92
 
     HDESK = HANDLE;
93
 
     HDROP = HANDLE;
94
 
     HDWP = HANDLE;
95
 
     HENHMETAFILE = HANDLE;
96
 
     HENV = HANDLE;
97
 
     HFILE = HANDLE;
98
 
     HFONT = HANDLE;
99
 
     HGDIOBJ = HANDLE;
100
 
     HGLOBAL = HANDLE;
101
 
     HGLRC = HANDLE;
102
 
     HHOOK = HANDLE;
103
 
     HICON = HANDLE;
104
 
     HIMAGELIST = HANDLE;
105
 
     HINST = HANDLE;   { Not HINSTANCE, else it has problems with the var HInstance }
106
 
     HKEY = HANDLE;
107
 
     HKL = HANDLE;
108
 
     HLOCAL = HANDLE;
109
 
     HMENU = HANDLE;
110
 
     HMETAFILE = HANDLE;
111
 
     HMODULE = HANDLE;
112
 
     HPALETTE = HANDLE;
113
 
     HPEN = HANDLE;
114
 
     HRASCONN = HANDLE;
115
 
     HRGN = HANDLE;
116
 
     HRSRC = HANDLE;
117
 
     HSTMT = HANDLE;
118
 
     HSTR  = HANDLE;
119
 
     HSZ = HANDLE;
120
 
     HWINSTA = HANDLE;
121
 
     HWND = HANDLE;
122
 
     HTASK = HANDLE;
123
 
 
124
 
     LANGID = word;
125
 
     LCID   = DWORD;
126
 
     LCTYPE = DWORD;
127
 
     LPARAM = longint;
128
 
 
129
 
     LP     = ^word;
130
 
     LPBOOL = ^WINBOOL;
131
 
     LPBYTE = ^BYTE;
132
 
     LPCCH  = PCHAR;
133
 
     LPCH   = PCHAR;
134
 
 
135
 
     LPCOLORREF = ^COLORREF;
136
 
 
137
 
     LPCSTR  = Pchar;
138
 
{$ifdef UNICODE}
139
 
     LPCTSTR = Pwidechar;
140
 
{$else}
141
 
     LPCTSTR = Pchar;
142
 
{$endif}
143
 
 
144
 
     LPCWCH  = Pwidechar;
145
 
     LPCWSTR = Pwidechar;
146
 
 
147
 
     LPDWORD = ^DWORD;
148
 
 
149
 
     LPHANDLE = ^HANDLE;
150
 
 
151
 
     LPINT  = ^longint;
152
 
     LPLONG = ^longint;
153
 
 
154
 
     LPSTR = Pchar;
155
 
{$ifdef UNICODE}
156
 
     LPTCH  = Pwidechar;
157
 
     LPTSTR = Pwidechar;
158
 
{$else}
159
 
     LPTCH  = Pchar;
160
 
     LPTSTR = Pchar;
161
 
{$endif}
162
 
 
163
 
     LRESULT = longint;
164
 
 
165
 
     LPVOID  = pointer;
166
 
     LPCVOID = pointer;
167
 
 
168
 
     LPWCH  = Pwidechar;
169
 
     LPWORD = ^word;
170
 
     LPWSTR = Pwidechar;
171
 
     NWPSTR = Pwidechar;
172
 
 
173
 
     PWINBOOL = ^WINBOOL;
174
 
     PBOOLEAN = ^BYTE;
175
 
 
176
 
     PBYTE = ^BYTE;
177
 
 
178
 
     PCCH = PCHAR;
179
 
     PCH  = PCHAR;
180
 
 
181
 
     PCSTR = Pchar;
182
 
 
183
 
     PCWCH  = Pwidechar;
184
 
     PCWSTR = Pwidechar;
185
 
 
186
 
     PDWORD = ^DWORD;
187
 
 
188
 
     PHANDLE = ^HANDLE;
189
 
     PHKEY = ^HKEY;
190
 
 
191
 
     PINT = ^longint;
192
 
     PLONG = ^longint;
193
 
     PSHORT = ^integer;
194
 
 
195
 
     PSTR = Pchar;
196
 
 
197
 
     PSZ = Pchar;
198
 
{$ifdef UNICODE}
199
 
     PTBYTE = ^word;
200
 
     PTCH = Pwidechar;
201
 
     PTCHAR = Pwidechar;
202
 
     PTSTR = Pwidechar;
203
 
{$else}
204
 
     PTBYTE = ^byte;
205
 
     PTCH   = Pchar;
206
 
     PTCHAR = Pchar;
207
 
     PTSTR  = Pchar;
208
 
{$endif}
209
 
 
210
 
     PUCHAR = ^byte;
211
 
     PWCH   = Pwidechar;
212
 
     PWCHAR = Pwidechar;
213
 
 
214
 
     PWORD   = ^word;
215
 
     PUINT   = ^cardinal;
216
 
     PULONG  = ^cardinal;
217
 
     PUSHORT = ^word;
218
 
 
219
 
     PVOID = pointer;
220
 
 
221
 
     RETCODE = integer;
222
 
 
223
 
     SC_HANDLE = HANDLE;
224
 
     SC_LOCK = LPVOID;
225
 
     LPSC_HANDLE = ^SC_HANDLE;
226
 
 
227
 
     SERVICE_STATUS_HANDLE = DWORD;
228
 
 
229
 
{$ifdef UNICODE}
230
 
     TBYTE = word;
231
 
     TCHAR = word;
232
 
     BCHAR = word;
233
 
{$else}
234
 
     TBYTE = byte;
235
 
     TCHAR = char;
236
 
     BCHAR = BYTE;
237
 
{$endif}
238
 
 
239
 
     UCHAR = byte;
240
 
     WCHAR = WideChar;
241
 
 
242
 
     UINT   = cardinal;
243
 
     ULONG  = cardinal;
244
 
     USHORT = word;
245
 
 
246
 
     WPARAM = Longint;
247
 
     PLPSTR = ^LPSTR;
248
 
     PLPWStr= ^LPWStr;
249
 
 
250
 
{
251
 
  Enumerations
252
 
}
253
 
 
254
 
     ACL_INFORMATION_CLASS = (AclRevisionInformation := 1,AclSizeInformation
255
 
       );
256
 
 
257
 
     _ACL_INFORMATION_CLASS = ACL_INFORMATION_CLASS;
258
 
 
259
 
     MEDIA_TYPE = (Unknown,F5_1Pt2_512,F3_1Pt44_512,F3_2Pt88_512,
260
 
       F3_20Pt8_512,F3_720_512,F5_360_512,F5_320_512,
261
 
       F5_320_1024,F5_180_512,F5_160_512,RemovableMedia,
262
 
       FixedMedia);
263
 
 
264
 
     _MEDIA_TYPE = MEDIA_TYPE;
265
 
 
266
 
  const
267
 
     RASCS_DONE = $2000;
268
 
     RASCS_PAUSED = $1000;
269
 
 
270
 
  type
271
 
 
272
 
     RASCONNSTATE = (RASCS_OpenPort := 0,RASCS_PortOpened,
273
 
       RASCS_ConnectDevice,RASCS_DeviceConnected,
274
 
       RASCS_AllDevicesConnected,RASCS_Authenticate,
275
 
       RASCS_AuthNotify,RASCS_AuthRetry,RASCS_AuthCallback,
276
 
       RASCS_AuthChangePassword,RASCS_AuthProject,
277
 
       RASCS_AuthLinkSpeed,RASCS_AuthAck,RASCS_ReAuthenticate,
278
 
       RASCS_Authenticated,RASCS_PrepareForCallback,
279
 
       RASCS_WaitForModemReset,RASCS_WaitForCallback,
280
 
       RASCS_Projected,RASCS_StartAuthentication,
281
 
       RASCS_CallbackComplete,RASCS_LogonNetwork,
282
 
       RASCS_Interactive := RASCS_PAUSED,RASCS_RetryAuthentication,
283
 
       RASCS_CallbackSetByCaller,RASCS_PasswordExpired,
284
 
       RASCS_Connected := RASCS_DONE,RASCS_Disconnected
285
 
       );
286
 
 
287
 
     _RASCONNSTATE = RASCONNSTATE;
288
 
 
289
 
     RASPROJECTION = (RASP_Amb := $10000,RASP_PppNbf := $803F,RASP_PppIpx := $802B,
290
 
       RASP_PppIp := $8021);
291
 
 
292
 
     _RASPROJECTION = RASPROJECTION;
293
 
 
294
 
     SECURITY_IMPERSONATION_LEVEL = (SecurityAnonymous,SecurityIdentification,
295
 
       SecurityImpersonation,SecurityDelegation
296
 
       );
297
 
 
298
 
     _SECURITY_IMPERSONATION_LEVEL = SECURITY_IMPERSONATION_LEVEL;
299
 
 
300
 
     SID_NAME_USE = (SidTypeUser := 1,SidTypeGroup,SidTypeDomain,
301
 
       SidTypeAlias,SidTypeWellKnownGroup,SidTypeDeletedAccount,
302
 
       SidTypeInvalid,SidTypeUnknown);
303
 
 
304
 
     PSID_NAME_USE = ^SID_NAME_USE;
305
 
 
306
 
     _SID_NAME_USE = SID_NAME_USE;
307
 
 
308
 
     TOKEN_INFORMATION_CLASS = (TokenUser := 1,TokenGroups,TokenPrivileges,
309
 
       TokenOwner,TokenPrimaryGroup,TokenDefaultDacl,
310
 
       TokenSource,TokenType,TokenImpersonationLevel,
311
 
       TokenStatistics);
312
 
 
313
 
     _TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS;
314
 
     TTokenInformationClass   = TOKEN_INFORMATION_CLASS;
315
 
 
316
 
     TOKEN_TYPE = (TokenPrimary := 1,TokenImpersonation
317
 
       );
318
 
 
319
 
     tagTOKEN_TYPE = TOKEN_TYPE;
320
 
 
321
 
 {
322
 
   Macros
323
 
 }
324
 
 
325
 
  { was #define dname(params) def_expr }
326
 
  { argument types are unknown }
327
 
  function GetBValue(rgb : longint) : BYTE;
328
 
 
329
 
  { was #define dname(params) def_expr }
330
 
  { argument types are unknown }
331
 
  function GetGValue(rgb : longint) : BYTE;
332
 
 
333
 
  { was #define dname(params) def_expr }
334
 
  { argument types are unknown }
335
 
  function GetRValue(rgb : longint) : BYTE;
336
 
 
337
 
  { was #define dname(params) def_expr }
338
 
  { argument types are unknown }
339
 
  function RGB(r,g,b : longint) : DWORD;
340
 
 
341
 
  {  Not convertable by H2PAS
342
 
  #define HANDLE_WM_NOTIFY(hwnd, wParam, lParam, fn) \
343
 
      (fn)((hwnd), (int)(wParam), (NMHDR FAR )(lParam))
344
 
   }
345
 
 
346
 
  { was #define dname(params) def_expr }
347
 
  { argument types are unknown }
348
 
  function HIBYTE(w : longint) : BYTE;
349
 
 
350
 
  { was #define dname(params) def_expr }
351
 
  { argument types are unknown }
352
 
  function HIWORD(l : longint) : WORD;
353
 
 
354
 
  { was #define dname(params) def_expr }
355
 
  { argument types are unknown }
356
 
  function LOBYTE(w : longint) : BYTE;
357
 
 
358
 
  { was #define dname(params) def_expr }
359
 
  { argument types are unknown }
360
 
  function LOWORD(l : longint) : WORD;
361
 
 
362
 
  { was #define dname(params) def_expr }
363
 
  { argument types are unknown }
364
 
  function MAKELONG(a,b : longint) : LONG;
365
 
 
366
 
  { was #define dname(params) def_expr }
367
 
  { argument types are unknown }
368
 
  function MAKEWORD(a,b : longint) : WORD;
369
 
 
370
 
  { original Cygnus headers also had the following defined:  }
371
 
  { was #define dname(params) def_expr }
372
 
  { argument types are unknown }
373
 
  { return type might be wrong }
374
 
  function SEXT_HIWORD(l : longint) : longint;
375
 
    { return type might be wrong }
376
 
 
377
 
  { was #define dname(params) def_expr }
378
 
  { argument types are unknown }
379
 
  { return type might be wrong }
380
 
  function ZEXT_HIWORD(l : longint) : longint;
381
 
    { return type might be wrong }
382
 
 
383
 
  { was #define dname(params) def_expr }
384
 
  { argument types are unknown }
385
 
  function SEXT_LOWORD(l : longint) : longint;
386
 
 
387
 
  { was #define dname(params) def_expr }
388
 
  { argument types are unknown }
389
 
  { return type might be wrong }
390
 
  function INDEXTOOVERLAYMASK(i : longint) : longint;
391
 
    { return type might be wrong }
392
 
 
393
 
  { was #define dname(params) def_expr }
394
 
  { argument types are unknown }
395
 
  { return type might be wrong }
396
 
  function INDEXTOSTATEIMAGEMASK(i : longint) : longint;
397
 
    { return type might be wrong }
398
 
 
399
 
  { was #define dname(params) def_expr }
400
 
  { argument types are unknown }
401
 
  function MAKEINTATOM(i : longint) : LPTSTR;
402
 
 
403
 
  { was #define dname(params) def_expr }
404
 
  { argument types are unknown }
405
 
  function MAKEINTRESOURCE(i : longint) : LPTSTR;
406
 
 
407
 
  { was #define dname(params) def_expr }
408
 
  { argument types are unknown }
409
 
  { return type might be wrong }
410
 
  function MAKELANGID(p,s : longint) : longint;
411
 
    { return type might be wrong }
412
 
 
413
 
  { was #define dname(params) def_expr }
414
 
  { argument types are unknown }
415
 
  function PRIMARYLANGID(lgid : longint) : WORD;
416
 
 
417
 
  { was #define dname(params) def_expr }
418
 
  { argument types are unknown }
419
 
  { return type might be wrong }
420
 
  function SUBLANGID(lgid : longint) : longint;
421
 
    { return type might be wrong }
422
 
 
423
 
  { was #define dname(params) def_expr }
424
 
  { argument types are unknown }
425
 
  function LANGIDFROMLCID(lcid : longint) : WORD;
426
 
 
427
 
  { was #define dname(params) def_expr }
428
 
  { argument types are unknown }
429
 
  function SORTIDFROMLCID(lcid : longint) : WORD;
430
 
 
431
 
  { was #define dname(params) def_expr }
432
 
  { argument types are unknown }
433
 
  function MAKELCID(lgid,srtid : longint) : DWORD;
434
 
 
435
 
  { was #define dname(params) def_expr }
436
 
  { argument types are unknown }
437
 
  function MAKELPARAM(l,h : longint) : LPARAM;
438
 
 
439
 
  { was #define dname(params) def_expr }
440
 
  { argument types are unknown }
441
 
  function MAKELRESULT(l,h : longint) : LRESULT;
442
 
 
443
 
  {  Not convertable by H2PAS
444
 
  #define MAKEPOINTS(l)   ( ((POINTS FAR  ) & (l)))
445
 
   }
446
 
  { was #define dname(params) def_expr }
447
 
  { argument types are unknown }
448
 
  function MAKEROP4(fore,back : longint) : DWORD;
449
 
 
450
 
  { was #define dname(params) def_expr }
451
 
  { argument types are unknown }
452
 
  function MAKEWPARAM(l,h : longint) : WPARAM;
453
 
 
454
 
{$ifndef max}
455
 
  { was #define dname(params) def_expr }
456
 
  { argument types are unknown }
457
 
  { return type might be wrong }
458
 
  function max(a,b : longint) : longint;
459
 
    { return type might be wrong }
460
 
 
461
 
{$endif}
462
 
{$ifndef min}
463
 
  { was #define dname(params) def_expr }
464
 
  { argument types are unknown }
465
 
  { return type might be wrong }
466
 
  function min(a,b : longint) : longint;
467
 
    { return type might be wrong }
468
 
 
469
 
{$endif}
470
 
  { was #define dname(params) def_expr }
471
 
  { argument types are unknown }
472
 
  function PALETTEINDEX(i : longint) : COLORREF;
473
 
 
474
 
  { was #define dname(params) def_expr }
475
 
  { argument types are unknown }
476
 
  { return type might be wrong }
477
 
  function PALETTERGB(r,g,b : longint) : longint;
478
 
    { return type might be wrong }
479
 
 
480
 
  (*  Not convertable by H2PAS
481
 
  #define POINTSTOPOINT(pt, pts) {(pt).x = (SHORT) LOWORD(pts); \
482
 
        (pt).y = (SHORT) HIWORD(pts);}
483
 
  #define POINTTOPOINTS(pt) \
484
 
      (MAKELONG((short) ((pt).x), (short) ((pt).y)))
485
 
   *)
486
 
  { already declared before
487
 
  #define INDEXTOOVERLAYMASK(i) ((i) << 8)
488
 
  #define INDEXTOSTATEIMAGEMASK(i) ((i) << 12)
489
 
   }
490
 
  {  Not convertable by H2PAS
491
 
  #ifdef UNICODE
492
 
  #define TEXT(quote) L##quote
493
 
  #else
494
 
  #define TEXT(quote) quote
495
 
  #endif
496
 
   }
497
 
 
498
 
 {
499
 
    Definitions for callback procedures
500
 
 }
501
 
 
502
 
 type
503
 
 
504
 
     BFFCALLBACK = function (_para1:HWND; _para2:UINT; _para3:LPARAM; _para4:LPARAM):longint;stdcall;
505
 
 
506
 
     LPCCHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
507
 
 
508
 
     LPCFHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
509
 
 
510
 
     PTHREAD_START_ROUTINE = Pointer;
511
 
 
512
 
     LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
513
 
 
514
 
     EDITSTREAMCALLBACK = function (_para1:DWORD; _para2:LPBYTE; _para3:LONG; _para4:LONG):DWORD;stdcall;
515
 
 
516
 
     LPFRHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
517
 
 
518
 
     LPOFNHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
519
 
 
520
 
     LPPRINTHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
521
 
 
522
 
     LPSETUPHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
523
 
 
524
 
     DLGPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):LRESULT;stdcall;
525
 
 
526
 
     PFNPROPSHEETCALLBACK = function (_para1:HWND; _para2:UINT; _para3:LPARAM):longint;stdcall;
527
 
 
528
 
     LPSERVICE_MAIN_FUNCTION = procedure (_para1:DWORD; _para2:LPTSTR);stdcall;
529
 
 
530
 
     PFNTVCOMPARE = function (_para1:LPARAM; _para2:LPARAM; _para3:LPARAM):longint;stdcall;
531
 
 
532
 
     WNDPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):LRESULT;stdcall;
533
 
 
534
 
     FARPROC = pointer;
535
 
 
536
 
     PROC = FARPROC;
537
 
 
538
 
     ENUMRESTYPEPROC = function (_para1:HANDLE; _para2:LPTSTR; _para3:LONG):WINBOOL;stdcall;
539
 
 
540
 
     ENUMRESNAMEPROC = function (_para1:HANDLE; _para2:LPCTSTR; _para3:LPTSTR; _para4:LONG):WINBOOL;stdcall;
541
 
 
542
 
     ENUMRESLANGPROC = function (_para1:HANDLE; _para2:LPCTSTR; _para3:LPCTSTR; _para4:WORD; _para5:LONG):WINBOOL;stdcall;
543
 
 
544
 
     DESKTOPENUMPROC = FARPROC;
545
 
 
546
 
     ENUMWINDOWSPROC = function (_para1:HWND; _para2:LPARAM):WINBOOL;stdcall;
547
 
 
548
 
     ENUMWINDOWSTATIONPROC = function (_para1:LPTSTR; _para2:LPARAM):WINBOOL;stdcall;
549
 
 
550
 
     SENDASYNCPROC = procedure (_para1:HWND; _para2:UINT; _para3:DWORD; _para4:LRESULT);stdcall;
551
 
 
552
 
     TIMERPROC = procedure (_para1:HWND; _para2:UINT; _para3:UINT; _para4:DWORD);stdcall;
553
 
 
554
 
     GRAYSTRINGPROC = FARPROC;
555
 
 
556
 
     DRAWSTATEPROC = function (_para1:HDC; _para2:LPARAM; _para3:WPARAM; _para4:longint; _para5:longint):WINBOOL;stdcall;
557
 
 
558
 
     PROPENUMPROCEX = function (_para1:HWND; _para2:LPCTSTR; _para3:HANDLE; _para4:DWORD):WINBOOL;stdcall;
559
 
 
560
 
     PROPENUMPROC = function (_para1:HWND; _para2:LPCTSTR; _para3:HANDLE):WINBOOL;stdcall;
561
 
 
562
 
     HOOKPROC = function (_para1:longint; _para2:WPARAM; _para3:LPARAM):LRESULT;stdcall;
563
 
 
564
 
     ENUMOBJECTSPROC = procedure (_para1:LPVOID; _para2:LPARAM);stdcall;
565
 
 
566
 
     LINEDDAPROC = procedure (_para1:longint; _para2:longint; _para3:LPARAM);stdcall;
567
 
 
568
 
     TABORTPROC = function (_para1:HDC; _para2:longint):WINBOOL;stdcall;
569
 
 
570
 
     LPPAGEPAINTHOOK = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
571
 
 
572
 
     LPPAGESETUPHOOK = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall;
573
 
 
574
 
     ICMENUMPROC = function (_para1:LPTSTR; _para2:LPARAM):longint;stdcall;
575
 
 
576
 
     EDITWORDBREAKPROCEX = function (_para1:pchar; _para2:LONG; _para3:BYTE; _para4:WINT):LONG;stdcall;
577
 
 
578
 
     PFNLVCOMPARE = function (_para1:LPARAM; _para2:LPARAM; _para3:LPARAM):longint;stdcall;
579
 
 
580
 
     LOCALE_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall;
581
 
 
582
 
     CODEPAGE_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall;
583
 
 
584
 
     DATEFMT_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall;
585
 
 
586
 
     TIMEFMT_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall;
587
 
 
588
 
     CALINFO_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall;
589
 
 
590
 
     PHANDLER_ROUTINE = function (_para1:DWORD):WINBOOL;stdcall;
591
 
 
592
 
     LPHANDLER_FUNCTION = function (_para1:DWORD):WINBOOL;stdcall;
593
 
 
594
 
     PFNGETPROFILEPATH = function (_para1:LPCTSTR; _para2:LPSTR; _para3:UINT):UINT;stdcall;
595
 
 
596
 
     PFNRECONCILEPROFILE = function (_para1:LPCTSTR; _para2:LPCTSTR; _para3:DWORD):UINT;stdcall;
597
 
 
598
 
     PFNPROCESSPOLICIES = function (_para1:HWND; _para2:LPCTSTR; _para3:LPCTSTR; _para4:LPCTSTR; _para5:DWORD):WINBOOL;stdcall;
599
 
  (*  Not convertable by H2PAS
600
 
  #define SECURITY_NULL_SID_AUTHORITY     {0,0,0,0,0,0}
601
 
  #define SECURITY_WORLD_SID_AUTHORITY    {0,0,0,0,0,1}
602
 
  #define SECURITY_LOCAL_SID_AUTHORITY    {0,0,0,0,0,2}
603
 
  #define SECURITY_CREATOR_SID_AUTHORITY  {0,0,0,0,0,3}
604
 
  #define SECURITY_NON_UNIQUE_AUTHORITY   {0,0,0,0,0,4}
605
 
  #define SECURITY_NT_AUTHORITY           {0,0,0,0,0,5}
606
 
   *)
607
 
  { TEXT("String") replaced by "String" below for H2PAS  }
608
 
 
609
 
  const
610
 
     SE_CREATE_TOKEN_NAME = 'SeCreateTokenPrivilege';
611
 
     SE_ASSIGNPRIMARYTOKEN_NAME = 'SeAssignPrimaryTokenPrivilege';
612
 
     SE_LOCK_MEMORY_NAME = 'SeLockMemoryPrivilege';
613
 
     SE_INCREASE_QUOTA_NAME = 'SeIncreaseQuotaPrivilege';
614
 
     SE_UNSOLICITED_INPUT_NAME = 'SeUnsolicitedInputPrivilege';
615
 
     SE_MACHINE_ACCOUNT_NAME = 'SeMachineAccountPrivilege';
616
 
     SE_TCB_NAME = 'SeTcbPrivilege';
617
 
     SE_SECURITY_NAME = 'SeSecurityPrivilege';
618
 
     SE_TAKE_OWNERSHIP_NAME = 'SeTakeOwnershipPrivilege';
619
 
     SE_LOAD_DRIVER_NAME = 'SeLoadDriverPrivilege';
620
 
     SE_SYSTEM_PROFILE_NAME = 'SeSystemProfilePrivilege';
621
 
     SE_SYSTEMTIME_NAME = 'SeSystemtimePrivilege';
622
 
     SE_PROF_SINGLE_PROCESS_NAME = 'SeProfileSingleProcessPrivilege';
623
 
     SE_INC_BASE_PRIORITY_NAME = 'SeIncreaseBasePriorityPrivilege';
624
 
     SE_CREATE_PAGEFILE_NAME = 'SeCreatePagefilePrivilege';
625
 
     SE_CREATE_PERMANENT_NAME = 'SeCreatePermanentPrivilege';
626
 
     SE_BACKUP_NAME = 'SeBackupPrivilege';
627
 
     SE_RESTORE_NAME = 'SeRestorePrivilege';
628
 
     SE_SHUTDOWN_NAME = 'SeShutdownPrivilege';
629
 
     SE_DEBUG_NAME = 'SeDebugPrivilege';
630
 
     SE_AUDIT_NAME = 'SeAuditPrivilege';
631
 
     SE_SYSTEM_ENVIRONMENT_NAME = 'SeSystemEnvironmentPrivilege';
632
 
     SE_CHANGE_NOTIFY_NAME = 'SeChangeNotifyPrivilege';
633
 
     SE_REMOTE_SHUTDOWN_NAME = 'SeRemoteShutdownPrivilege';
634
 
  {  Not convertable by H2PAS
635
 
  #define SERVICES_ACTIVE_DATABASEW      L"ServicesActive"
636
 
  #define SERVICES_FAILED_DATABASEW      L"ServicesFailed"
637
 
   }
638
 
     SERVICES_ACTIVE_DATABASEA = 'ServicesActive';
639
 
     SERVICES_FAILED_DATABASEA = 'ServicesFailed';
640
 
  {  Not convertable by H2PAS
641
 
  #define SC_GROUP_IDENTIFIERW           L'+'
642
 
   }
643
 
     SC_GROUP_IDENTIFIERA = '+';
644
 
{$ifdef UNICODE}
645
 
     SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEW;
646
 
     SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEW;
647
 
     SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERW;
648
 
{$else}
649
 
     SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA;
650
 
     SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA;
651
 
     SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA;
652
 
{$endif}
653
 
 
654
 
type
655
 
 
656
 
     { PFNCALLBACK = CALLB; }
657
 
     PFNCALLBACK = function(_para1, _para2: UINT;_para3: HCONV;_para4, _para5: HSZ; _para6: HDDEDATA;_para7 ,_para8 :DWORD): HDDEData;stdcall;
658
 
     { CALLB = procedure ;CDECL; }
659
 
       CALLB = PFNCALLBACK;
660
 
 
661
 
 
662
 
     SECURITY_CONTEXT_TRACKING_MODE = WINBOOL;
663
 
  { End of stuff from ddeml.h in old Cygnus headers  }
664
 
  { -----------------------------------------------  }
665
 
 
666
 
     WNDENUMPROC = FARPROC;
667
 
 
668
 
     ENHMFENUMPROC = FARPROC;
669
 
 
670
 
     CCSTYLE = DWORD;
671
 
 
672
 
     PCCSTYLE = ^CCSTYLE;
673
 
 
674
 
     LPCCSTYLE = ^CCSTYLE;
675
 
 
676
 
     CCSTYLEFLAGA = DWORD;
677
 
 
678
 
     PCCSTYLEFLAGA = ^CCSTYLEFLAGA;
679
 
 
680
 
     LPCCSTYLEFLAGA = ^CCSTYLEFLAGA;
681
 
 
682
 
{$endif read_interface}
683
 
 
684
 
 
685
 
{$ifdef read_implementation}
686
 
 
687
 
  { was #define dname(params) def_expr }
688
 
  { argument types are unknown }
689
 
  function GetBValue(rgb : longint) : BYTE;
690
 
    begin
691
 
       GetBValue:=BYTE(rgb shr 16);
692
 
    end;
693
 
 
694
 
  { was #define dname(params) def_expr }
695
 
  { argument types are unknown }
696
 
  function GetGValue(rgb : longint) : BYTE;
697
 
    begin
698
 
       GetGValue:=BYTE((WORD(rgb)) shr 8);
699
 
    end;
700
 
 
701
 
  { was #define dname(params) def_expr }
702
 
  { argument types are unknown }
703
 
  function GetRValue(rgb : longint) : BYTE;
704
 
    begin
705
 
       GetRValue:=BYTE(rgb);
706
 
    end;
707
 
 
708
 
  { was #define dname(params) def_expr }
709
 
  { argument types are unknown }
710
 
  function RGB(r,g,b : longint) : DWORD;
711
 
    begin
712
 
       RGB:=DWORD(((DWORD(BYTE(r))) or ((DWORD(WORD(g))) shl 8)) or ((DWORD(BYTE(b))) shl 16));
713
 
    end;
714
 
 
715
 
  { was #define dname(params) def_expr }
716
 
  { argument types are unknown }
717
 
  function HIBYTE(w : longint) : BYTE;
718
 
    begin
719
 
       HIBYTE:=BYTE(((WORD(w)) shr 8) and $FF);
720
 
    end;
721
 
 
722
 
  { was #define dname(params) def_expr }
723
 
  { argument types are unknown }
724
 
  function HIWORD(l : longint) : WORD;
725
 
    begin
726
 
       HIWORD:=WORD(((DWORD(l)) shr 16) and $FFFF);
727
 
    end;
728
 
 
729
 
  { was #define dname(params) def_expr }
730
 
  { argument types are unknown }
731
 
  function LOBYTE(w : longint) : BYTE;
732
 
    begin
733
 
       LOBYTE:=BYTE(w);
734
 
    end;
735
 
 
736
 
  { was #define dname(params) def_expr }
737
 
  { argument types are unknown }
738
 
  function LOWORD(l : longint) : WORD;
739
 
    begin
740
 
       LOWORD:=WORD(l);
741
 
    end;
742
 
 
743
 
  { was #define dname(params) def_expr }
744
 
  { argument types are unknown }
745
 
  function MAKELONG(a,b : longint) : LONG;
746
 
    begin
747
 
       MAKELONG:=LONG((WORD(a)) or ((DWORD(WORD(b))) shl 16));
748
 
    end;
749
 
 
750
 
  { was #define dname(params) def_expr }
751
 
  { argument types are unknown }
752
 
  function MAKEWORD(a,b : longint) : WORD;
753
 
    begin
754
 
       MAKEWORD:=WORD((BYTE(a)) or ((WORD(BYTE(b))) shl 8));
755
 
    end;
756
 
 
757
 
  { was #define dname(params) def_expr }
758
 
  { argument types are unknown }
759
 
  { return type might be wrong }
760
 
  function SEXT_HIWORD(l : longint) : longint;
761
 
    { return type might be wrong }
762
 
    begin
763
 
       SEXT_HIWORD:=(longint(l)) shr 16;
764
 
    end;
765
 
 
766
 
  { was #define dname(params) def_expr }
767
 
  { argument types are unknown }
768
 
  { return type might be wrong }
769
 
  function ZEXT_HIWORD(l : longint) : longint;
770
 
    { return type might be wrong }
771
 
    begin
772
 
       ZEXT_HIWORD:=(cardinal(l)) shr 16;
773
 
    end;
774
 
 
775
 
  { was #define dname(params) def_expr }
776
 
  { argument types are unknown }
777
 
  function SEXT_LOWORD(l : longint) : longint;
778
 
    begin
779
 
       SEXT_LOWORD:=longint(integer(l));
780
 
    end;
781
 
 
782
 
  { was #define dname(params) def_expr }
783
 
  { argument types are unknown }
784
 
  { return type might be wrong }
785
 
  function INDEXTOOVERLAYMASK(i : longint) : longint;
786
 
    { return type might be wrong }
787
 
    begin
788
 
       INDEXTOOVERLAYMASK:=i shl 8;
789
 
    end;
790
 
 
791
 
  { was #define dname(params) def_expr }
792
 
  { argument types are unknown }
793
 
  { return type might be wrong }
794
 
  function INDEXTOSTATEIMAGEMASK(i : longint) : longint;
795
 
    { return type might be wrong }
796
 
    begin
797
 
       INDEXTOSTATEIMAGEMASK:=i shl 12;
798
 
    end;
799
 
 
800
 
  { was #define dname(params) def_expr }
801
 
  { argument types are unknown }
802
 
  function MAKEINTATOM(i : longint) : LPTSTR;
803
 
    begin
804
 
       MAKEINTATOM:=LPTSTR(DWORD(WORD(i)));
805
 
    end;
806
 
 
807
 
  { was #define dname(params) def_expr }
808
 
  { argument types are unknown }
809
 
  function MAKEINTRESOURCE(i : longint) : LPTSTR;
810
 
    begin
811
 
       MAKEINTRESOURCE:=LPTSTR(DWORD(WORD(i)));
812
 
    end;
813
 
 
814
 
  { was #define dname(params) def_expr }
815
 
  { argument types are unknown }
816
 
  { return type might be wrong }
817
 
  function MAKELANGID(p,s : longint) : longint;
818
 
    { return type might be wrong }
819
 
    begin
820
 
       MAKELANGID:=((WORD(s)) shl 10) or (WORD(p));
821
 
    end;
822
 
 
823
 
  { was #define dname(params) def_expr }
824
 
  { argument types are unknown }
825
 
  function PRIMARYLANGID(lgid : longint) : WORD;
826
 
    begin
827
 
       { PRIMARYLANGID:=WORD(lgid(@($3ff)));
828
 
         h2pas error here corrected by hand PM }
829
 
       PRIMARYLANGID:=WORD(lgid) and ($3ff);
830
 
    end;
831
 
 
832
 
  { was #define dname(params) def_expr }
833
 
  { argument types are unknown }
834
 
  { return type might be wrong }
835
 
  function SUBLANGID(lgid : longint) : longint;
836
 
    { return type might be wrong }
837
 
    begin
838
 
       SUBLANGID:=(WORD(lgid)) shr 10;
839
 
    end;
840
 
 
841
 
  { was #define dname(params) def_expr }
842
 
  { argument types are unknown }
843
 
  function LANGIDFROMLCID(lcid : longint) : WORD;
844
 
    begin
845
 
       LANGIDFROMLCID:=WORD(lcid);
846
 
    end;
847
 
 
848
 
  { was #define dname(params) def_expr }
849
 
  { argument types are unknown }
850
 
  function SORTIDFROMLCID(lcid : longint) : WORD;
851
 
    begin
852
 
       SORTIDFROMLCID:=WORD(((DWORD(lcid)) and $000FFFFF) shr 16);
853
 
    end;
854
 
 
855
 
  { was #define dname(params) def_expr }
856
 
  { argument types are unknown }
857
 
  function MAKELCID(lgid,srtid : longint) : DWORD;
858
 
    begin
859
 
       MAKELCID:=DWORD(((DWORD(WORD(srtid))) shl 16) or (DWORD(WORD(lgid))));
860
 
    end;
861
 
 
862
 
  { was #define dname(params) def_expr }
863
 
  { argument types are unknown }
864
 
  function MAKELPARAM(l,h : longint) : LPARAM;
865
 
    begin
866
 
       MAKELPARAM:=LPARAM(MAKELONG(l,h));
867
 
    end;
868
 
 
869
 
  { was #define dname(params) def_expr }
870
 
  { argument types are unknown }
871
 
  function MAKELRESULT(l,h : longint) : LRESULT;
872
 
    begin
873
 
       MAKELRESULT:=LRESULT(MAKELONG(l,h));
874
 
    end;
875
 
 
876
 
  { was #define dname(params) def_expr }
877
 
  { argument types are unknown }
878
 
  function MAKEROP4(fore,back : longint) : DWORD;
879
 
    begin
880
 
       MAKEROP4:=DWORD((DWORD(back shl 8) and $FF000000) or DWORD(fore));
881
 
    end;
882
 
 
883
 
  { was #define dname(params) def_expr }
884
 
  { argument types are unknown }
885
 
  function MAKEWPARAM(l,h : longint) : WPARAM;
886
 
    begin
887
 
       MAKEWPARAM:=WPARAM(MAKELONG(l,h));
888
 
    end;
889
 
 
890
 
  { was #define dname(params) def_expr }
891
 
  { argument types are unknown }
892
 
  { return type might be wrong }
893
 
  function max(a,b : longint) : longint;
894
 
    { return type might be wrong }
895
 
    var
896
 
       if_local1 : longint;
897
 
    (* result types are not known *)
898
 
    begin
899
 
       if a > b then
900
 
         if_local1:=a
901
 
       else
902
 
         if_local1:=b;
903
 
       max:=if_local1;
904
 
    end;
905
 
 
906
 
  { was #define dname(params) def_expr }
907
 
  { argument types are unknown }
908
 
  { return type might be wrong }
909
 
  function min(a,b : longint) : longint;
910
 
    { return type might be wrong }
911
 
    var
912
 
       if_local1 : longint;
913
 
    (* result types are not known *)
914
 
    begin
915
 
       if a < b then
916
 
         if_local1:=a
917
 
       else
918
 
         if_local1:=b;
919
 
       min:=if_local1;
920
 
    end;
921
 
 
922
 
  { was #define dname(params) def_expr }
923
 
  { argument types are unknown }
924
 
  function PALETTEINDEX(i : longint) : COLORREF;
925
 
    begin
926
 
       PALETTEINDEX:=COLORREF($01000000 or (DWORD(WORD(i))));
927
 
    end;
928
 
 
929
 
  { was #define dname(params) def_expr }
930
 
  { argument types are unknown }
931
 
  { return type might be wrong }
932
 
  function PALETTERGB(r,g,b : longint) : longint;
933
 
    { return type might be wrong }
934
 
    begin
935
 
       PALETTERGB:=$02000000 or (RGB(r,g,b));
936
 
    end;
937
 
 
938
 
{$endif read_implementation}
939
 
 
940
 
{
941
 
  $Log: base.inc,v $
942
 
  Revision 1.21  2003/12/08 21:23:24  peter
943
 
    * hmodule added
944
 
 
945
 
  Revision 1.20  2003/12/05 11:53:12  marco
946
 
   * ttokeninformationclass alias for delphi compat
947
 
 
948
 
  Revision 1.19  2003/10/06 23:52:53  florian
949
 
    * some data types cleaned up
950
 
 
951
 
  Revision 1.18  2003/08/20 23:12:32  marco
952
 
   * HSTR fix
953
 
 
954
 
  Revision 1.17  2003/04/23 11:35:00  peter
955
 
    * wndproc definition fixed
956
 
 
957
 
  Revision 1.16  2003/04/01 15:37:17  peter
958
 
    * HResult is alias for System.HResult
959
 
    * Handle is unique type of Cardinal
960
 
 
961
 
  Revision 1.15  2002/12/12 17:34:35  peter
962
 
    * Renaming INT type to WINT
963
 
 
964
 
  Revision 1.14  2002/11/27 20:08:21  peter
965
 
    * added PBOOL
966
 
 
967
 
  Revision 1.13  2002/10/09 20:45:12  florian
968
 
    - NULL definition removed, the system unit contains now a NULL variant
969
 
 
970
 
  Revision 1.12  2002/10/06 20:00:22  peter
971
 
    * Use Widechar in the Windows unit
972
 
 
973
 
  Revision 1.11  2002/09/15 17:53:45  peter
974
 
    * Remove Float type, use Single instead
975
 
 
976
 
  Revision 1.10  2002/09/07 16:01:30  peter
977
 
    * old logs removed and tabs fixed
978
 
 
979
 
  Revision 1.9  2002/07/16 13:52:14  florian
980
 
    * LARGE_INT and ULARGE_INT types fixed
981
 
    * LONGLONG defined properly
982
 
 
983
 
}
 
 
b'\\ No newline at end of file'