include/windef.h

   1 /*
   2  * Basic types definitions
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #ifndef __WINE_WINDEF_H
   8 #define __WINE_WINDEF_H
   9
  10 #ifdef __WINE__
  11 # include "config.h"
  12 # undef UNICODE
  13 #endif  /* __WINE__ */
  14
  15 #ifdef __cplusplus
  16 extern "C" {
  17 #endif
  18
  19 /* Misc. constants. */
  20
  21 #ifdef FALSE
  22 #undef FALSE
  23 #endif
  24 #define FALSE 0
  25
  26 #ifdef TRUE
  27 #undef TRUE
  28 #endif
  29 #define TRUE  1
  30
  31 #ifdef NULL
  32 #undef NULL
  33 #endif
  34 #define NULL  0
  35
  36 /* Macros to map Winelib names to the correct implementation name */
  37 /* depending on __WINE__ and UNICODE macros.                      */
  38 /* Note that Winelib is purely Win32.                             */
  39
  40 #ifdef __WINE__
  41 # define WINELIB_NAME_AW(func) \
  42     func##_must_be_suffixed_with_W_or_A_in_this_context \
  43     func##_must_be_suffixed_with_W_or_A_in_this_context
  44 #else  /* __WINE__ */
  45 # ifdef UNICODE
  46 #  define WINELIB_NAME_AW(func) func##W
  47 # else
  48 #  define WINELIB_NAME_AW(func) func##A
  49 # endif  /* UNICODE */
  50 #endif  /* __WINE__ */
  51
  52 #ifdef __WINE__
  53 # define DECL_WINELIB_TYPE_AW(type)  /* nothing */
  54 #else   /* __WINE__ */
  55 # define DECL_WINELIB_TYPE_AW(type)  typedef WINELIB_NAME_AW(type) type;
  56 #endif  /* __WINE__ */
  57
  58 #ifndef NONAMELESSSTRUCT
  59 # if defined(__WINE__) || !defined(_FORCENAMELESSSTRUCT)
  60 #  define NONAMELESSSTRUCT
  61 # endif
  62 #endif /* !defined(NONAMELESSSTRUCT) */
  63
  64 #ifndef NONAMELESSUNION
  65 # if defined(__WINE__) || !defined(_FORCENAMELESSUNION) || !defined(__cplusplus)
  66 #  define NONAMELESSUNION
  67 # endif
  68 #endif /* !defined(NONAMELESSUNION) */
  69
  70 #ifndef NONAMELESSSTRUCT
  71 #define DUMMYSTRUCTNAME
  72 #define DUMMYSTRUCTNAME1
  73 #define DUMMYSTRUCTNAME2
  74 #define DUMMYSTRUCTNAME3
  75 #define DUMMYSTRUCTNAME4
  76 #define DUMMYSTRUCTNAME5
  77 #else /* !defined(NONAMELESSSTRUCT) */
  78 #define DUMMYSTRUCTNAME   s
  79 #define DUMMYSTRUCTNAME1  s1
  80 #define DUMMYSTRUCTNAME2  s2
  81 #define DUMMYSTRUCTNAME3  s3
  82 #define DUMMYSTRUCTNAME4  s4
  83 #define DUMMYSTRUCTNAME5  s5
  84 #endif /* !defined(NONAMELESSSTRUCT) */
  85
  86 #ifndef NONAMELESSUNION
  87 #define DUMMYUNIONNAME
  88 #define DUMMYUNIONNAME1
  89 #define DUMMYUNIONNAME2
  90 #define DUMMYUNIONNAME3
  91 #define DUMMYUNIONNAME4
  92 #define DUMMYUNIONNAME5
  93 #else /* !defined(NONAMELESSUNION) */
  94 #define DUMMYUNIONNAME   u
  95 #define DUMMYUNIONNAME1  u1
  96 #define DUMMYUNIONNAME2  u2
  97 #define DUMMYUNIONNAME3  u3
  98 #define DUMMYUNIONNAME4  u4
  99 #define DUMMYUNIONNAME5  u5
 100 #endif /* !defined(NONAMELESSUNION) */
 101
 102 /* Calling conventions definitions */
 103
 104 #ifdef __i386__
 105 # if defined(__GNUC__) && ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 7)))
 106 #  define __stdcall __attribute__((__stdcall__))
 107 #  define __cdecl   __attribute__((__cdecl__))
 108 #  define __RESTORE_ES  __asm__ __volatile__("pushl %ds\n\tpopl %es")
 109 # else
 110 #  error You need gcc >= 2.7 to build Wine on a 386
 111 # endif  /* __GNUC__ */
 112 #else  /* __i386__ */
 113 # define __stdcall
 114 # define __cdecl
 115 # define __RESTORE_ES
 116 #endif  /* __i386__ */
 117
 118 #define CALLBACK    __stdcall
 119 #define WINAPI      __stdcall
 120 #define APIPRIVATE  __stdcall
 121 #define PASCAL      __stdcall
 122 #define pascal      __stdcall
 123 #define _pascal     __stdcall
 124 #define _stdcall    __stdcall
 125 #define _fastcall   __stdcall
 126 #define __export    __stdcall
 127 #define CDECL       __cdecl
 128 #define _CDECL      __cdecl
 129 #define cdecl       __cdecl
 130 #define _cdecl      __cdecl
 131 #define WINAPIV     __cdecl
 132 #define APIENTRY    WINAPI
 133
 134 #define __declspec(x)
 135 #define dllimport
 136 #define dllexport
 137
 138 #define CONST       const
 139
 140 /* Standard data types. These are the same for emulator and library. */
 141
 142 typedef void            VOID;
 143 typedef int             INT;
 144 typedef unsigned int    UINT;
 145 typedef unsigned short  WORD;
 146 typedef unsigned long   DWORD;
 147 typedef unsigned long   ULONG;
 148 typedef unsigned char   BYTE;
 149 typedef long            LONG;
 150 typedef short           SHORT;
 151 typedef unsigned short  USHORT;
 152 typedef char            CHAR;
 153 typedef unsigned char   UCHAR;
 154 /* Some systems might have wchar_t, but we really need 16 bit characters */
 155 typedef unsigned short  WCHAR;
 156 typedef int             BOOL;
 157 typedef double          DATE;
 158 typedef double          DOUBLE;
 159 typedef double          LONGLONG;
 160 typedef double          ULONGLONG;
 161
 162 /* FIXME: Wine does not compile with strict on, therefore strict
 163  * handles are presently only usable on machines where sizeof(UINT) ==
 164  * sizeof(void*).  HANDLEs are supposed to be void* but a large amount
 165  * of WINE code operates on HANDLES as if they are UINTs. So to WINE
 166  * they exist as UINTs but to the Winelib user who turns on strict,
 167  * they exist as void*. If there is a size difference between UINT and
 168  * void* then things get ugly.  */
 169 #ifdef STRICT
 170 typedef VOID*           HANDLE;
 171 #else
 172 typedef UINT            HANDLE;
 173 #endif
 174
 175
 176 typedef HANDLE         *LPHANDLE;
 177
 178 /* Integer types. These are the same for emulator and library. */
 179 typedef UINT            WPARAM;
 180 typedef LONG            LPARAM;
 181 typedef LONG            HRESULT;
 182 typedef LONG            LRESULT;
 183 typedef WORD            ATOM;
 184 typedef WORD            CATCHBUF[9];
 185 typedef WORD           *LPCATCHBUF;
 186 typedef HANDLE          HHOOK;
 187 typedef HANDLE          HMONITOR;
 188 typedef DWORD           LCID;
 189 typedef WORD            LANGID;
 190 typedef DWORD           LCTYPE;
 191 typedef float           FLOAT;
 192
 193 /* Pointers types. These are the same for emulator and library. */
 194 /* winnt types */
 195 typedef VOID           *PVOID;
 196 typedef const void     *PCVOID;
 197 typedef CHAR           *PCHAR;
 198 typedef UCHAR          *PUCHAR;
 199 typedef BYTE           *PBYTE;
 200 typedef WORD           *PWORD;
 201 typedef USHORT         *PUSHORT;
 202 typedef SHORT          *PSHORT;
 203 typedef ULONG          *PULONG;
 204 typedef LONG           *PLONG;
 205 typedef DWORD          *PDWORD;
 206 /* common win32 types */
 207 typedef CHAR           *LPSTR;
 208 typedef CHAR           *PSTR;
 209 typedef const CHAR     *LPCSTR;
 210 typedef const CHAR     *PCSTR;
 211 typedef WCHAR          *LPWSTR;
 212 typedef WCHAR          *PWSTR;
 213 typedef const WCHAR    *LPCWSTR;
 214 typedef const WCHAR    *PCWSTR;
 215 typedef BYTE           *LPBYTE;
 216 typedef WORD           *LPWORD;
 217 typedef DWORD          *LPDWORD;
 218 typedef LONG           *LPLONG;
 219 typedef VOID           *LPVOID;
 220 typedef const VOID     *LPCVOID;
 221 typedef INT            *PINT;
 222 typedef INT            *LPINT;
 223 typedef UINT           *PUINT;
 224 typedef UINT           *LPUINT;
 225 typedef FLOAT          *PFLOAT;
 226 typedef FLOAT          *LPFLOAT;
 227 typedef BOOL           *PBOOL;
 228 typedef BOOL           *LPBOOL;
 229
 230 /* Special case: a segmented pointer is just a pointer in the user's code. */
 231
 232 #ifdef __WINE__
 233 typedef DWORD SEGPTR;
 234 #else
 235 typedef void* SEGPTR;
 236 #endif /* __WINE__ */
 237
 238 /* Handle types that exist both in Win16 and Win32. */
 239
 240 #ifdef STRICT
 241 #define DECLARE_HANDLE(a) \
 242         typedef struct a##__ { int unused; } *a; \
 243         typedef a *P##a; \
 244         typedef a *LP##a
 245 #else /*STRICT*/
 246 #define DECLARE_HANDLE(a) \
 247         typedef HANDLE a; \
 248         typedef a *P##a; \
 249         typedef a *LP##a
 250 #endif /*STRICT*/
 251
 252 DECLARE_HANDLE(HACMDRIVERID);
 253 DECLARE_HANDLE(HACMDRIVER);
 254 DECLARE_HANDLE(HACMOBJ);
 255 DECLARE_HANDLE(HACMSTREAM);
 256 DECLARE_HANDLE(HMETAFILEPICT);
 257
 258 DECLARE_HANDLE(HACCEL);
 259 DECLARE_HANDLE(HBITMAP);
 260 DECLARE_HANDLE(HBRUSH);
 261 DECLARE_HANDLE(HCOLORSPACE);
 262 DECLARE_HANDLE(HCURSOR);
 263 DECLARE_HANDLE(HDC);
 264 DECLARE_HANDLE(HDROP);
 265 DECLARE_HANDLE(HDRVR);
 266 DECLARE_HANDLE(HDWP);
 267 DECLARE_HANDLE(HENHMETAFILE);
 268 DECLARE_HANDLE(HFILE);
 269 DECLARE_HANDLE(HFONT);
 270 DECLARE_HANDLE(HICON);
 271 DECLARE_HANDLE(HINSTANCE);
 272 DECLARE_HANDLE(HKEY);
 273 DECLARE_HANDLE(HMENU);
 274 DECLARE_HANDLE(HMETAFILE);
 275 DECLARE_HANDLE(HMIDI);
 276 DECLARE_HANDLE(HMIDIIN);
 277 DECLARE_HANDLE(HMIDIOUT);
 278 DECLARE_HANDLE(HMIDISTRM);
 279 DECLARE_HANDLE(HMIXER);
 280 DECLARE_HANDLE(HMIXEROBJ);
 281 DECLARE_HANDLE(HMMIO);
 282 DECLARE_HANDLE(HPALETTE);
 283 DECLARE_HANDLE(HPEN);
 284 DECLARE_HANDLE(HQUEUE);
 285 DECLARE_HANDLE(HRGN);
 286 DECLARE_HANDLE(HRSRC);
 287 DECLARE_HANDLE(HTASK);
 288 DECLARE_HANDLE(HWAVE);
 289 DECLARE_HANDLE(HWAVEIN);
 290 DECLARE_HANDLE(HWAVEOUT);
 291 DECLARE_HANDLE(HWINSTA);
 292 DECLARE_HANDLE(HDESK);
 293 DECLARE_HANDLE(HWND);
 294 DECLARE_HANDLE(HKL);
 295 DECLARE_HANDLE(HIC);
 296 DECLARE_HANDLE(HRASCONN);
 297 #undef DECLARE_HANDLE
 298
 299 /* Handle types that must remain interchangeable even with strict on */
 300
 301 typedef HINSTANCE HMODULE;
 302 typedef HANDLE HGDIOBJ;
 303 typedef HANDLE HGLOBAL;
 304 typedef HANDLE HLOCAL;
 305 typedef HANDLE GLOBALHANDLE;
 306 typedef HANDLE LOCALHANDLE;
 307
 308 /* Callback function pointers types */
 309
 310 typedef BOOL    (CALLBACK* DATEFMT_ENUMPROCA)(LPSTR);
 311 typedef BOOL    (CALLBACK* DATEFMT_ENUMPROCW)(LPWSTR);
 312 DECL_WINELIB_TYPE_AW(DATEFMT_ENUMPROC)
 313 typedef BOOL    (CALLBACK *DLGPROC)(HWND,UINT,WPARAM,LPARAM);
 314 typedef LRESULT (CALLBACK *DRIVERPROC)(DWORD,HDRVR,UINT,LPARAM,LPARAM);
 315 typedef INT     (CALLBACK *EDITWORDBREAKPROCA)(LPSTR,INT,INT,INT);
 316 typedef INT     (CALLBACK *EDITWORDBREAKPROCW)(LPWSTR,INT,INT,INT);
 317 DECL_WINELIB_TYPE_AW(EDITWORDBREAKPROC)
 318 typedef LRESULT (CALLBACK *FARPROC)();
 319 typedef INT     (CALLBACK *PROC)();
 320 typedef BOOL    (CALLBACK *GRAYSTRINGPROC)(HDC,LPARAM,INT);
 321 typedef LRESULT (CALLBACK *HOOKPROC)(INT,WPARAM,LPARAM);
 322 typedef BOOL    (CALLBACK *PROPENUMPROCA)(HWND,LPCSTR,HANDLE);
 323 typedef BOOL    (CALLBACK *PROPENUMPROCW)(HWND,LPCWSTR,HANDLE);
 324 DECL_WINELIB_TYPE_AW(PROPENUMPROC)
 325 typedef BOOL    (CALLBACK *PROPENUMPROCEXA)(HWND,LPCSTR,HANDLE,LPARAM);
 326 typedef BOOL    (CALLBACK *PROPENUMPROCEXW)(HWND,LPCWSTR,HANDLE,LPARAM);
 327 DECL_WINELIB_TYPE_AW(PROPENUMPROCEX)
 328 typedef BOOL    (CALLBACK* TIMEFMT_ENUMPROCA)(LPSTR);
 329 typedef BOOL    (CALLBACK* TIMEFMT_ENUMPROCW)(LPWSTR);
 330 DECL_WINELIB_TYPE_AW(TIMEFMT_ENUMPROC)
 331 typedef VOID    (CALLBACK *TIMERPROC)(HWND,UINT,UINT,DWORD);
 332 typedef BOOL (CALLBACK *WNDENUMPROC)(HWND,LPARAM);
 333 typedef LRESULT (CALLBACK *WNDPROC)(HWND,UINT,WPARAM,LPARAM);
 334
 335 /*----------------------------------------------------------------------------
 336 ** FIXME:  Better isolate Wine's reliance on the xxx16 type definitions.
 337 **         For now, we just isolate them to make the situation clear.
 338 **--------------------------------------------------------------------------*/
 339 #include "wine/windef16.h"
 340
 341 /* Define some empty macros for compatibility with Windows code. */
 342
 343 #ifndef __WINE__
 344 #define NEAR
 345 #define FAR
 346 #define near
 347 #define far
 348 #define _near
 349 #define _far
 350 #define IN
 351 #define OUT
 352 #define OPTIONAL
 353 #endif  /* __WINE__ */
 354
 355 /* Macro for structure packing. */
 356
 357 #ifdef __GNUC__
 358 #define WINE_PACKED   __attribute__((packed))
 359 #define WINE_UNUSED   __attribute__((unused))
 360 #define WINE_NORETURN __attribute__((noreturn))
 361 #else
 362 #define WINE_PACKED    /* nothing */
 363 #define WINE_UNUSED    /* nothing */
 364 #define WINE_NORETURN  /* nothing */
 365 #endif
 366
 367 /* Macros to split words and longs. */
 368
 369 #define LOBYTE(w)              ((BYTE)(WORD)(w))
 370 #define HIBYTE(w)              ((BYTE)((WORD)(w) >> 8))
 371
 372 #define LOWORD(l)              ((WORD)(DWORD)(l))
 373 #define HIWORD(l)              ((WORD)((DWORD)(l) >> 16))
 374
 375 #define SLOWORD(l)             ((INT16)(LONG)(l))
 376 #define SHIWORD(l)             ((INT16)((LONG)(l) >> 16))
 377
 378 #define MAKEWORD(low,high)     ((WORD)(((BYTE)(low)) | ((WORD)((BYTE)(high))) << 8))
 379 #define MAKELONG(low,high)     ((LONG)(((WORD)(low)) | (((DWORD)((WORD)(high))) << 16)))
 380 #define MAKELPARAM(low,high)   ((LPARAM)MAKELONG(low,high))
 381 #define MAKEWPARAM(low,high)   ((WPARAM)MAKELONG(low,high))
 382 #define MAKELRESULT(low,high)  ((LRESULT)MAKELONG(low,high))
 383 #define MAKEINTATOM(atom)      ((LPCSTR)MAKELONG((atom),0))
 384
 385 #define SELECTOROF(ptr)     (HIWORD(ptr))
 386 #define OFFSETOF(ptr)       (LOWORD(ptr))
 387
 388 #ifdef __WINE__
 389 /* macros to set parts of a DWORD (not in the Windows API) */
 390 #define SET_LOWORD(dw,val)  ((dw) = ((dw) & 0xffff0000) | LOWORD(val))
 391 #define SET_LOBYTE(dw,val)  ((dw) = ((dw) & 0xffffff00) | LOBYTE(val))
 392 #define SET_HIBYTE(dw,val)  ((dw) = ((dw) & 0xffff00ff) | (LOWORD(val) & 0xff00))
 393 #define ADD_LOWORD(dw,val)  ((dw) = ((dw) & 0xffff0000) | LOWORD((DWORD)(dw)+(val)))
 394 #endif
 395
 396 /* Macros to access unaligned or wrong-endian WORDs and DWORDs. */
 397 /* Note: These macros are semantically broken, at least for wrc.  wrc
 398    spits out data in the platform's current binary format, *not* in
 399    little-endian format.  These macros are used throughout the resource
 400    code to load and store data to the resources.  Since it is unlikely
 401    that we'll ever be dealing with little-endian resource data, the
 402    byte-swapping nature of these macros has been disabled.  Rather than
 403    remove the use of these macros from the resource loading code, the
 404    macros have simply been disabled.  In the future, someone may want
 405    to reactivate these macros for other purposes.  In that case, the
 406    resource code will have to be modified to use different macros. */
 407
 408 #if 1
 409 #define PUT_WORD(ptr,w)   (*(WORD *)(ptr) = (w))
 410 #define GET_WORD(ptr)     (*(WORD *)(ptr))
 411 #define PUT_DWORD(ptr,dw) (*(DWORD *)(ptr) = (dw))
 412 #define GET_DWORD(ptr)    (*(DWORD *)(ptr))
 413 #else
 414 #define PUT_WORD(ptr,w)   (*(BYTE *)(ptr) = LOBYTE(w), \
 415                            *((BYTE *)(ptr) + 1) = HIBYTE(w))
 416 #define GET_WORD(ptr)     ((WORD)(*(BYTE *)(ptr) | \
 417                                   (WORD)(*((BYTE *)(ptr)+1) << 8)))
 418 #define PUT_DWORD(ptr,dw) (PUT_WORD((ptr),LOWORD(dw)), \
 419                            PUT_WORD((WORD *)(ptr)+1,HIWORD(dw)))
 420 #define GET_DWORD(ptr)    ((DWORD)(GET_WORD(ptr) | \
 421                                    ((DWORD)GET_WORD((WORD *)(ptr)+1) << 16)))
 422 #endif  /* 1 */
 423
 424 /* MIN and MAX macros */
 425
 426 #ifdef MAX
 427 #undef MAX
 428 #endif
 429 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
 430
 431 #ifdef MIN
 432 #undef MIN
 433 #endif
 434 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
 435
 436 #define __max(a,b) MAX(a,b)
 437 #define __min(a,b) MIN(a,b)
 438 #ifndef max
 439 #define max(a,b)   MAX(a,b)
 440 #endif
 441 #ifndef min
 442 #define min(a,b)   MIN(a,b)
 443 #endif
 444
 445 #define _MAX_PATH  260
 446 #define MAX_PATH   260
 447 #define _MAX_DRIVE 3
 448 #define _MAX_DIR   256
 449 #define _MAX_FNAME 255
 450 #define _MAX_EXT   256
 451
 452 #define HFILE_ERROR16   ((HFILE16)-1)
 453 #define HFILE_ERROR     ((HFILE)-1)
 454
 455 /* The SIZE structure */
 456 typedef struct tagSIZE
 457 {
 458     INT  cx;
 459     INT  cy;
 460 } SIZE, *PSIZE, *LPSIZE;
 461
 462
 463 typedef SIZE SIZEL, *PSIZEL, *LPSIZEL;
 464
 465 #define CONV_SIZE16TO32(s16,s32) \
 466             ((s32)->cx = (INT)(s16)->cx, (s32)->cy = (INT)(s16)->cy)
 467 #define CONV_SIZE32TO16(s32,s16) \
 468             ((s16)->cx = (INT16)(s32)->cx, (s16)->cy = (INT16)(s32)->cy)
 469
 470 /* The POINT structure */
 471 typedef struct tagPOINT
 472 {
 473     LONG  x;
 474     LONG  y;
 475 } POINT, *PPOINT, *LPPOINT;
 476
 477 typedef struct _POINTL
 478 {
 479     LONG x;
 480     LONG y;
 481 } POINTL;
 482
 483 #define CONV_POINT16TO32(p16,p32) \
 484             ((p32)->x = (INT)(p16)->x, (p32)->y = (INT)(p16)->y)
 485 #define CONV_POINT32TO16(p32,p16) \
 486             ((p16)->x = (INT16)(p32)->x, (p16)->y = (INT16)(p32)->y)
 487
 488 #define MAKEPOINT16(l) (*((POINT16 *)&(l)))
 489
 490 /* The POINTS structure */
 491
 492 typedef struct tagPOINTS
 493 {
 494         SHORT x;
 495         SHORT y;
 496 } POINTS, *PPOINTS, *LPPOINTS;
 497
 498
 499 #define MAKEPOINTS(l)  (*((POINTS *)&(l)))
 500
 501
 502 /* The RECT structure */
 503 typedef struct tagRECT
 504 {
 505     INT  left;
 506     INT  top;
 507     INT  right;
 508     INT  bottom;
 509 } RECT, *PRECT, *LPRECT;
 510 typedef const RECT *LPCRECT;
 511
 512
 513 typedef struct tagRECTL
 514 {
 515     LONG left;
 516     LONG top;
 517     LONG right;
 518     LONG bottom;
 519 } RECTL, *PRECTL, *LPRECTL;
 520
 521 typedef const RECTL *LPCRECTL;
 522
 523 #define CONV_RECT16TO32(r16,r32) \
 524     ((r32)->left  = (INT)(r16)->left,  (r32)->top    = (INT)(r16)->top, \
 525      (r32)->right = (INT)(r16)->right, (r32)->bottom = (INT)(r16)->bottom)
 526 #define CONV_RECT32TO16(r32,r16) \
 527     ((r16)->left  = (INT16)(r32)->left,  (r16)->top    = (INT16)(r32)->top, \
 528      (r16)->right = (INT16)(r32)->right, (r16)->bottom = (INT16)(r32)->bottom)
 529
 530 #ifdef __cplusplus
 531 }
 532 #endif
 533
 534 #endif /* __WINE_WINDEF_H */