reactos/include/structs.h

   1 /*
   2    Structures.h
   3
   4    Declarations for all the Windows32 API Structures
   5
   6    Copyright (C) 1996 Free Software Foundation, Inc.
   7
   8    Author:  Scott Christley <scottc@net-community.com>
   9    Date: 1996
  10
  11    This file is part of the Windows32 API Library.
  12
  13    This library is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU Library General Public
  15    License as published by the Free Software Foundation; either
  16    version 2 of the License, or (at your option) any later version.
  17
  18    This library is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    Library General Public License for more details.
  22
  23    If you are interested in a warranty or support for this source code,
  24    contact Scott Christley <scottc@net-community.com> for more information.
  25
  26    You should have received a copy of the GNU Library General Public
  27    License along with this library; see the file COPYING.LIB.
  28    If not, write to the Free Software Foundation,
  29    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  30 */
  31
  32
  33 #ifndef _GNU_H_WINDOWS32_STRUCTURES
  34 #define _GNU_H_WINDOWS32_STRUCTURES
  35
  36 #include <base.h>
  37 #include <ntos/security.h>
  38 #include <ntos/time.h>
  39 #include <ntdll/rtl.h>
  40 #include <ntos/console.h>
  41 #include <ntos/keyboard.h>
  42 #include <ntos/heap.h>
  43 #include <ntos/mm.h>
  44 #include <ntos/file.h>
  45 #include <ntos/ps.h>
  46 #include <ntos/disk.h>
  47 #include <ntos/gditypes.h>
  48
  49 /* NOTE - _DISABLE_TIDENTS exists to keep ReactOS's source from
  50    accidentally utilitizing ANSI/UNICODE-generic structs, defines
  51    or functions. */
  52 #ifndef _DISABLE_TIDENTS
  53 #  ifdef UNICODE
  54 #    define typedef_tident(ident) typedef ident##W ident;
  55 #  else
  56 #    define typedef_tident(ident) typedef ident##A ident;
  57 #  endif
  58 #else
  59 #  define typedef_tident(ident)
  60 #endif
  61
  62 typedef struct _VALENT_A {
  63    LPSTR ve_valuename;
  64    DWORD ve_valuelen;
  65    DWORD ve_valueptr;
  66    DWORD ve_type;
  67 } VALENTA, *PVALENTA;
  68
  69 typedef struct _VALENT_W {
  70    LPWSTR ve_valuename;
  71    DWORD  ve_valuelen;
  72    DWORD  ve_valueptr;
  73    DWORD  ve_type;
  74 } VALENTW, *PVALENTW;
  75
  76 typedef_tident(VALENT)
  77 typedef_tident(PVALENT)
  78
  79 #ifndef WIN32_LEAN_AND_MEAN
  80
  81 #ifdef __cplusplus
  82 extern "C" {
  83 #endif /* __cplusplus */
  84
  85 typedef struct _ABC {
  86   int     abcA;
  87   UINT    abcB;
  88   int     abcC;
  89 } ABC, *LPABC;
  90
  91 typedef struct _ABCFLOAT {
  92   FLOAT   abcfA;
  93   FLOAT   abcfB;
  94   FLOAT   abcfC;
  95 } ABCFLOAT, *LPABCFLOAT;
  96
  97 typedef struct tagACCEL {
  98   BYTE   fVirt;
  99   WORD   key;
 100   WORD   cmd;
 101 } ACCEL, *LPACCEL;
 102
 103 typedef struct tagACCESSTIMEOUT {
 104   UINT  cbSize;
 105   DWORD dwFlags;
 106   DWORD iTimeOutMSec;
 107 } ACCESSTIMEOUT;
 108
 109 typedef struct _ACTION_HEADER {
 110   ULONG   transport_id;
 111   USHORT  action_code;
 112   USHORT  reserved;
 113 } ACTION_HEADER;
 114
 115 typedef struct _ADAPTER_STATUS {
 116   UCHAR   adapter_address[6];
 117   UCHAR   rev_major;
 118   UCHAR   reserved0;
 119   UCHAR   adapter_type;
 120   UCHAR   rev_minor;
 121   WORD    duration;
 122   WORD    frmr_recv;
 123   WORD    frmr_xmit;
 124   WORD    iframe_recv_err;
 125   WORD    xmit_aborts;
 126   DWORD   xmit_success;
 127   DWORD   recv_success;
 128   WORD    iframe_xmit_err;
 129   WORD    recv_buff_unavail;
 130   WORD    t1_timeouts;
 131   WORD    ti_timeouts;
 132   DWORD   reserved1;
 133   WORD    free_ncbs;
 134   WORD    max_cfg_ncbs;
 135   WORD    max_ncbs;
 136   WORD    xmit_buf_unavail;
 137   WORD    max_dgram_size;
 138   WORD    pending_sess;
 139   WORD    max_cfg_sess;
 140   WORD    max_sess;
 141   WORD    max_sess_pkt_size;
 142   WORD    name_count;
 143 } ADAPTER_STATUS;
 144
 145 typedef struct _ADDJOB_INFO_1A {
 146   LPSTR   Path;
 147   DWORD   JobId;
 148 } ADDJOB_INFO_1A;
 149
 150 typedef struct _ADDJOB_INFO_1W {
 151   LPWSTR  Path;
 152   DWORD   JobId;
 153 } ADDJOB_INFO_1W;
 154
 155 typedef_tident(ADDJOB_INFO_1)
 156
 157 typedef struct tagANIMATIONINFO {
 158   UINT cbSize;
 159   int  iMinAnimate;
 160 } ANIMATIONINFO, *LPANIMATIONINFO;
 161
 162 typedef struct _RECT {
 163   LONG left;
 164   LONG top;
 165   LONG right;
 166   LONG bottom;
 167 } RECT, *LPRECT, *LPCRECT, *PRECT,
 168 RECTL, *LPRECTL, *LPCRECTL, *PRECTL;
 169
 170 typedef struct _PATRECT {
 171         RECT r;
 172         HBRUSH hBrush;
 173 } PATRECT, * PPATRECT;
 174
 175 #if 0
 176 typedef struct _RECTL {
 177   LONG left;
 178   LONG top;
 179   LONG right;
 180   LONG bottom;
 181 } RECTL, *LPRECTL, *LPCRECTL, *PRECTL;
 182 #endif
 183
 184 typedef struct _AppBarData {
 185   DWORD  cbSize;
 186   HWND   hWnd;
 187   UINT   uCallbackMessage;
 188   UINT   uEdge;
 189   RECT   rc;
 190   LPARAM lParam;
 191 } APPBARDATA, *PAPPBARDATA;
 192
 193 typedef struct tagBITMAP
 194 {
 195   LONG        bmType;
 196   LONG        bmWidth;
 197   LONG        bmHeight;
 198   LONG        bmWidthBytes;
 199   WORD        bmPlanes;
 200   WORD        bmBitsPixel;
 201   LPVOID      bmBits;
 202 } BITMAP, *PBITMAP,   *NPBITMAP,   *LPBITMAP;
 203
 204 typedef struct tagBITMAPCOREHEADER {
 205   DWORD   bcSize;
 206   WORD    bcWidth;
 207   WORD    bcHeight;
 208   WORD    bcPlanes;
 209   WORD    bcBitCount;
 210 } BITMAPCOREHEADER;
 211
 212 typedef struct tagRGBTRIPLE {
 213   BYTE rgbtBlue;
 214   BYTE rgbtGreen;
 215   BYTE rgbtRed;
 216 } RGBTRIPLE, *PRGBTRIPLE;
 217
 218 typedef struct _BITMAPCOREINFO {
 219   BITMAPCOREHEADER  bmciHeader;
 220   RGBTRIPLE         bmciColors[1];
 221 } BITMAPCOREINFO, *PBITMAPCOREINFO, *LPBITMAPCOREINFO;
 222
 223 #include <pshpack1.h>
 224
 225 typedef struct tagBITMAPFILEHEADER {
 226   WORD    bfType;
 227   DWORD   bfSize;
 228   WORD    bfReserved1;
 229   WORD    bfReserved2;
 230   DWORD   bfOffBits;
 231 } BITMAPFILEHEADER;
 232
 233 #include <poppack.h>
 234
 235 typedef struct tagBITMAPINFOHEADER {
 236   DWORD  biSize;
 237   LONG   biWidth;
 238   LONG   biHeight;
 239   WORD   biPlanes;
 240   WORD   biBitCount;
 241   DWORD  biCompression;
 242   DWORD  biSizeImage;
 243   LONG   biXPelsPerMeter;
 244   LONG   biYPelsPerMeter;
 245   DWORD  biClrUsed;
 246   DWORD  biClrImportant;
 247 } BITMAPINFOHEADER, *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;
 248
 249 typedef struct tagRGBQUAD {
 250   BYTE    rgbBlue;
 251   BYTE    rgbGreen;
 252   BYTE    rgbRed;
 253   BYTE    rgbReserved;
 254 } RGBQUAD, *PRGBQUAD, *LPRGBQUAD;
 255
 256 typedef struct tagBITMAPINFO {
 257   BITMAPINFOHEADER bmiHeader;
 258   RGBQUAD          bmiColors[1];
 259 } BITMAPINFO, *LPBITMAPINFO, *PBITMAPINFO;
 260
 261 typedef long FXPT2DOT30,  * LPFXPT2DOT30;
 262
 263 typedef struct tagCIEXYZ
 264 {
 265   FXPT2DOT30 ciexyzX;
 266   FXPT2DOT30 ciexyzY;
 267   FXPT2DOT30 ciexyzZ;
 268 } CIEXYZ;
 269 typedef CIEXYZ  * LPCIEXYZ;
 270
 271 typedef struct tagCIEXYZTRIPLE
 272 {
 273   CIEXYZ  ciexyzRed;
 274   CIEXYZ  ciexyzGreen;
 275   CIEXYZ  ciexyzBlue;
 276 } CIEXYZTRIPLE;
 277 typedef CIEXYZTRIPLE  * LPCIEXYZTRIPLE;
 278
 279 typedef struct {
 280   DWORD        bV4Size;
 281   LONG         bV4Width;
 282   LONG         bV4Height;
 283   WORD         bV4Planes;
 284   WORD         bV4BitCount;
 285   DWORD        bV4V4Compression;
 286   DWORD        bV4SizeImage;
 287   LONG         bV4XPelsPerMeter;
 288   LONG         bV4YPelsPerMeter;
 289   DWORD        bV4ClrUsed;
 290   DWORD        bV4ClrImportant;
 291   DWORD        bV4RedMask;
 292   DWORD        bV4GreenMask;
 293   DWORD        bV4BlueMask;
 294   DWORD        bV4AlphaMask;
 295   DWORD        bV4CSType;
 296   CIEXYZTRIPLE bV4Endpoints;
 297   DWORD        bV4GammaRed;
 298   DWORD        bV4GammaGreen;
 299   DWORD        bV4GammaBlue;
 300 } BITMAPV4HEADER,   *LPBITMAPV4HEADER, *PBITMAPV4HEADER;
 301
 302 #ifndef __BLOB_T_DEFINED
 303 #define __BLOB_T_DEFINED
 304 typedef struct _BLOB {
 305   ULONG   cbSize;
 306   BYTE    *pBlobData;
 307 } BLOB, *PBLOB,*LPBLOB;
 308 #endif
 309
 310 typedef struct _SHITEMID {
 311   USHORT cb;
 312   BYTE   abID[1];
 313 } SHITEMID, * LPSHITEMID;
 314 typedef const SHITEMID  * LPCSHITEMID;
 315
 316 typedef struct _ITEMIDLIST {
 317   SHITEMID mkid;
 318 } ITEMIDLIST, * LPITEMIDLIST;
 319 typedef const ITEMIDLIST * LPCITEMIDLIST;
 320
 321 typedef struct _browseinfo {
 322   HWND hwndOwner;
 323   LPCITEMIDLIST pidlRoot;
 324   LPSTR pszDisplayName;
 325   LPCSTR lpszTitle;
 326   UINT ulFlags;
 327   BFFCALLBACK lpfn;
 328   LPARAM lParam;
 329   int iImage;
 330 } BROWSEINFO, *PBROWSEINFO, *LPBROWSEINFO;
 331
 332 typedef struct _BY_HANDLE_FILE_INFORMATION {
 333   DWORD    dwFileAttributes;
 334   FILETIME ftCreationTime;
 335   FILETIME ftLastAccessTime;
 336   FILETIME ftLastWriteTime;
 337   DWORD    dwVolumeSerialNumber;
 338   DWORD    nFileSizeHigh;
 339   DWORD    nFileSizeLow;
 340   DWORD    nNumberOfLinks;
 341   DWORD    nFileIndexHigh;
 342   DWORD    nFileIndexLow;
 343 } BY_HANDLE_FILE_INFORMATION, *LPBY_HANDLE_FILE_INFORMATION;
 344
 345 typedef struct _FIXED {
 346   WORD  fract;
 347   short value;
 348 } FIXED;
 349
 350 typedef struct tagPOINT {
 351   LONG x;
 352   LONG y;
 353 } POINT, *LPPOINT, *PPOINT;
 354
 355 typedef struct tagPOINTFX {
 356   FIXED x;
 357   FIXED y;
 358 } POINTFX;
 359
 360 typedef struct _POINTL {
 361   LONG x;
 362   LONG y;
 363 } POINTL, *PPOINTL;
 364
 365 typedef struct tagPOINTS {
 366   SHORT x;
 367   SHORT y;
 368 } POINTS;
 369
 370 typedef struct {
 371         ULONG State[4];
 372         ULONG Unknown[2];
 373 } MD4_CONTEXT, *PMD4_CONTEXT;
 374
 375 typedef struct {
 376         ULONG Unknown[2];
 377         ULONG State[4];
 378 } MD5_CONTEXT, *PMD5_CONTEXT;
 379
 380 typedef struct {
 381         ULONG Unknown1[6];
 382         ULONG State[5];
 383         ULONG Unknown2[2];
 384 } SHA_CONTEXT, *PSHA_CONTEXT;
 385
 386 typedef struct _tagCANDIDATEFORM {
 387   DWORD  dwIndex;
 388   DWORD  dwStyle;
 389   POINT  ptCurrentPos;
 390   RECT   rcArea;
 391 } CANDIDATEFORM, *LPCANDIDATEFORM;
 392
 393 typedef struct _tagCANDIDATELIST {
 394   DWORD  dwSize;
 395   DWORD  dwStyle;
 396   DWORD  dwCount;
 397   DWORD  dwSelection;
 398   DWORD  dwPageStart;
 399   DWORD  dwPageSize;
 400   DWORD  dwOffset[1];
 401 } CANDIDATELIST, *LPCANDIDATELIST;
 402
 403 typedef struct tagCREATESTRUCTA {
 404   LPVOID    lpCreateParams;
 405   HINSTANCE hInstance;
 406   HMENU     hMenu;
 407   HWND      hwndParent;
 408   int       cy;
 409   int       cx;
 410   int       y;
 411   int       x;
 412   LONG      style;
 413   LPCSTR   lpszName;
 414   LPCSTR   lpszClass;
 415   DWORD     dwExStyle;
 416 } CREATESTRUCTA, *LPCREATESTRUCTA;
 417
 418 typedef struct tagCREATESTRUCTW {
 419   LPVOID    lpCreateParams;
 420   HINSTANCE hInstance;
 421   HMENU     hMenu;
 422   HWND      hwndParent;
 423   int       cy;
 424   int       cx;
 425   int       y;
 426   int       x;
 427   LONG      style;
 428   LPCWSTR   lpszName;
 429   LPCWSTR   lpszClass;
 430   DWORD     dwExStyle;
 431 } CREATESTRUCTW, *LPCREATESTRUCTW;
 432
 433 typedef_tident(CREATESTRUCT)
 434 typedef_tident(LPCREATESTRUCT)
 435
 436 typedef struct tagHW_PROFILE_INFOA {
 437     DWORD  dwDockInfo;
 438     CHAR   szHwProfileGuid[HW_PROFILE_GUIDLEN];
 439     CHAR   szHwProfileName[MAX_PROFILE_LEN];
 440 } HW_PROFILE_INFOA, *LPHW_PROFILE_INFOA;
 441 typedef struct tagHW_PROFILE_INFOW {
 442     DWORD  dwDockInfo;
 443     WCHAR  szHwProfileGuid[HW_PROFILE_GUIDLEN];
 444     WCHAR  szHwProfileName[MAX_PROFILE_LEN];
 445 } HW_PROFILE_INFOW, *LPHW_PROFILE_INFOW;
 446
 447 typedef_tident(HW_PROFILE_INFO)
 448 typedef_tident(LPHW_PROFILE_INFO)
 449 typedef struct _tagDATETIME {
 450     WORD    year;
 451     WORD    month;
 452     WORD    day;
 453     WORD    hour;
 454     WORD    min;
 455     WORD    sec;
 456 } DATETIME;
 457
 458 typedef struct _tagIMEPROA {
 459     HWND        hWnd;
 460     DATETIME    InstDate;
 461     UINT        wVersion;
 462     BYTE        szDescription[50];
 463     BYTE        szName[80];
 464     BYTE        szOptions[30];
 465 } IMEPROA,*PIMEPROA,*NPIMEPROA,FAR *LPIMEPROA;
 466 typedef struct _tagIMEPROW {
 467     HWND        hWnd;
 468     DATETIME    InstDate;
 469     UINT        wVersion;
 470     WCHAR       szDescription[50];
 471     WCHAR       szName[80];
 472     WCHAR       szOptions[30];
 473 } IMEPROW,*PIMEPROW,*NPIMEPROW,FAR *LPIMEPROW;
 474 typedef_tident(IMEPRO)
 475 typedef_tident(NPIMEPRO)
 476 typedef_tident(LPIMEPRO)
 477 typedef_tident(PIMEPRO)
 478
 479 typedef struct _cpinfoexA {
 480     UINT    MaxCharSize;
 481     BYTE    DefaultChar[MAX_DEFAULTCHAR];
 482     BYTE    LeadByte[MAX_LEADBYTES];
 483     WCHAR   UnicodeDefaultChar;
 484     UINT    CodePage;
 485     CHAR    CodePageName[MAX_PATH];
 486 } CPINFOEXA, *LPCPINFOEXA;
 487 typedef struct _cpinfoexW {
 488     UINT    MaxCharSize;
 489     BYTE    DefaultChar[MAX_DEFAULTCHAR];
 490     BYTE    LeadByte[MAX_LEADBYTES];
 491     WCHAR   UnicodeDefaultChar;
 492     UINT    CodePage;
 493     WCHAR   CodePageName[MAX_PATH];
 494 } CPINFOEXW, *LPCPINFOEXW;
 495
 496 typedef_tident(CPINFOEX)
 497 typedef_tident(LPCPINFOEX)
 498
 499 typedef struct tagCBT_CREATEWNDA {
 500   LPCREATESTRUCTA lpcs;
 501   HWND            hwndInsertAfter;
 502 } CBT_CREATEWNDA;
 503
 504 typedef struct tagCBT_CREATEWNDW {
 505   LPCREATESTRUCTW lpcs;
 506   HWND            hwndInsertAfter;
 507 } CBT_CREATEWNDW;
 508
 509 typedef_tident(CBT_CREATEWND)
 510
 511 typedef struct tagCBTACTIVATESTRUCT {
 512   WINBOOL fMouse;
 513   HWND hWndActive;
 514 } CBTACTIVATESTRUCT;
 515
 516 typedef struct _CHAR_INFO {
 517   union {
 518     WCHAR UnicodeChar;
 519     CHAR AsciiChar;
 520   } Char;
 521   WORD Attributes;
 522 } CHAR_INFO, *PCHAR_INFO;
 523
 524 typedef struct _charformatA {
 525   UINT     cbSize;
 526   DWORD    dwMask;
 527   DWORD    dwEffects;
 528   LONG     yHeight;
 529   LONG     yOffset;
 530   COLORREF crTextColor;
 531   BYTE     bCharSet;
 532   BYTE     bPitchAndFamily;
 533   CHAR     szFaceName[LF_FACESIZE];
 534 } CHARFORMATA;
 535
 536 typedef struct _charformatW {
 537   UINT     cbSize;
 538   DWORD    dwMask;
 539   DWORD    dwEffects;
 540   LONG     yHeight;
 541   LONG     yOffset;
 542   COLORREF crTextColor;
 543   BYTE     bCharSet;
 544   BYTE     bPitchAndFamily;
 545   WCHAR    szFaceName[LF_FACESIZE];
 546 } CHARFORMATW;
 547
 548 typedef_tident(CHARFORMAT)
 549
 550 typedef struct _charrange {
 551   LONG cpMin;
 552   LONG cpMax;
 553 } CHARRANGE;
 554
 555 typedef struct tagCHARSET {
 556   DWORD aflBlock[3];
 557   DWORD flLang;
 558 } CHARSET;
 559
 560 typedef struct tagFONTSIGNATURE {
 561   DWORD  fsUsb[4];
 562   DWORD  fsCsb[2];
 563 } FONTSIGNATURE, *LPFONTSIGNATURE;
 564
 565 typedef struct {
 566   UINT ciCharset;
 567   UINT ciACP;
 568   FONTSIGNATURE fs;
 569 } CHARSETINFO, *LPCHARSETINFO;
 570
 571 typedef struct tagWCRANGE
 572 {
 573     WCHAR  wcLow;
 574     USHORT cGlyphs;
 575 } WCRANGE, *PWCRANGE,FAR *LPWCRANGE;
 576
 577 typedef struct tagGLYPHSET
 578 {
 579     DWORD    cbThis;
 580     DWORD    flAccel;
 581     DWORD    cGlyphsSupported;
 582     DWORD    cRanges;
 583     WCRANGE  ranges[1];
 584 } GLYPHSET, *PGLYPHSET, FAR *LPGLYPHSET;
 585
 586 typedef struct {
 587   DWORD        lStructSize;
 588   HWND         hwndOwner;
 589   HWND         hInstance;
 590   COLORREF     rgbResult;
 591   COLORREF*    lpCustColors;
 592   DWORD        Flags;
 593   LPARAM       lCustData;
 594   LPCCHOOKPROC lpfnHook;
 595   LPCSTR       lpTemplateName;
 596 } CHOOSECOLORA, *LPCHOOSECOLORA;
 597
 598 typedef struct {
 599   DWORD        lStructSize;
 600   HWND         hwndOwner;
 601   HWND         hInstance;
 602   COLORREF     rgbResult;
 603   COLORREF*    lpCustColors;
 604   DWORD        Flags;
 605   LPARAM       lCustData;
 606   LPCCHOOKPROC lpfnHook;
 607   LPCWSTR      lpTemplateName;
 608 } CHOOSECOLORW, *LPCHOOSECOLORW;
 609
 610 typedef_tident(CHOOSECOLOR)
 611 typedef_tident(LPCHOOSECOLOR)
 612
 613 typedef struct _OBJECT_TYPE_LIST {
 614     WORD   Level;
 615     WORD   Sbz;
 616     GUID *ObjectType;
 617 } OBJECT_TYPE_LIST, *POBJECT_TYPE_LIST;
 618
 619 typedef struct tagLOGFONTA {
 620   LONG lfHeight;
 621   LONG lfWidth;
 622   LONG lfEscapement;
 623   LONG lfOrientation;
 624   LONG lfWeight;
 625   BYTE lfItalic;
 626   BYTE lfUnderline;
 627   BYTE lfStrikeOut;
 628   BYTE lfCharSet;
 629   BYTE lfOutPrecision;
 630   BYTE lfClipPrecision;
 631   BYTE lfQuality;
 632   BYTE lfPitchAndFamily;
 633   CHAR lfFaceName[LF_FACESIZE];
 634 } LOGFONTA, *LPLOGFONTA, *PLOGFONTA;
 635
 636 typedef struct tagLOGFONTW {
 637   LONG lfHeight;
 638   LONG lfWidth;
 639   LONG lfEscapement;
 640   LONG lfOrientation;
 641   LONG lfWeight;
 642   BYTE lfItalic;
 643   BYTE lfUnderline;
 644   BYTE lfStrikeOut;
 645   BYTE lfCharSet;
 646   BYTE lfOutPrecision;
 647   BYTE lfClipPrecision;
 648   BYTE lfQuality;
 649   BYTE lfPitchAndFamily;
 650   WCHAR lfFaceName[LF_FACESIZE];
 651 } LOGFONTW, *LPLOGFONTW, *PLOGFONTW;
 652
 653 typedef_tident(LOGFONT)
 654 typedef_tident(LPLOGFONT)
 655 typedef_tident(PLOGFONT)
 656
 657 typedef struct tagRAWINPUTHEADER {
 658     DWORD dwType;
 659     DWORD dwSize;
 660     HANDLE hDevice;
 661     WPARAM wParam;
 662 } RAWINPUTHEADER, *PRAWINPUTHEADER, *LPRAWINPUTHEADER;
 663
 664 typedef struct tagRAWINPUTDEVICELIST {
 665     HANDLE hDevice;
 666     DWORD dwType;
 667 } RAWINPUTDEVICELIST, *PRAWINPUTDEVICELIST;
 668
 669 typedef struct tagRAWINPUTDEVICE {
 670     USHORT usUsagePage;
 671     USHORT usUsage;
 672     DWORD dwFlags;
 673     HWND hwndTarget;
 674 } RAWINPUTDEVICE, *PRAWINPUTDEVICE, *LPRAWINPUTDEVICE;
 675
 676 typedef CONST RAWINPUTDEVICE* PCRAWINPUTDEVICE;
 677
 678 typedef struct tagRAWMOUSE {
 679     USHORT usFlags;
 680     union {
 681         ULONG ulButtons;
 682         struct  {
 683             USHORT  usButtonFlags;
 684             USHORT  usButtonData;
 685         };
 686     };
 687     ULONG ulRawButtons;
 688     LONG lLastX;
 689     LONG lLastY;
 690     ULONG ulExtraInformation;
 691 } RAWMOUSE, *PRAWMOUSE, *LPRAWMOUSE;
 692
 693 typedef struct tagRAWKEYBOARD {
 694     USHORT MakeCode;
 695     USHORT Flags;
 696     USHORT Reserved;
 697     USHORT VKey;
 698     UINT   Message;
 699     ULONG ExtraInformation;
 700 } RAWKEYBOARD, *PRAWKEYBOARD, *LPRAWKEYBOARD;
 701
 702 typedef struct tagRAWHID {
 703     DWORD dwSizeHid;
 704     DWORD dwCount;
 705     BYTE bRawData[1];
 706 } RAWHID, *PRAWHID, *LPRAWHID;
 707
 708 typedef struct tagRAWINPUT {
 709     RAWINPUTHEADER header;
 710     union {
 711         RAWMOUSE    mouse;
 712         RAWKEYBOARD keyboard;
 713         RAWHID      hid;
 714     } data;
 715 } RAWINPUT, *PRAWINPUT, *LPRAWINPUT;
 716
 717 typedef struct tagCHOOSEFONTA {
 718   DWORD        lStructSize;
 719   HWND         hwndOwner;
 720   HDC          hDC;
 721   LPLOGFONTA   lpLogFont;
 722   INT          iPointSize;
 723   DWORD        Flags;
 724   DWORD        rgbColors;
 725   LPARAM       lCustData;
 726   LPCFHOOKPROC lpfnHook;
 727   LPCSTR       lpTemplateName;
 728   HINSTANCE    hInstance;
 729   LPSTR        lpszStyle;
 730   WORD         nFontType;
 731   WORD         ___MISSING_ALIGNMENT__;
 732   INT          nSizeMin;
 733   INT          nSizeMax;
 734 } CHOOSEFONTA, *LPCHOOSEFONTA;
 735
 736 typedef struct tagCHOOSEFONTW {
 737   DWORD        lStructSize;
 738   HWND         hwndOwner;
 739   HDC          hDC;
 740   LPLOGFONTW   lpLogFont;
 741   INT          iPointSize;
 742   DWORD        Flags;
 743   DWORD        rgbColors;
 744   LPARAM       lCustData;
 745   LPCFHOOKPROC lpfnHook;
 746   LPCWSTR      lpTemplateName;
 747   HINSTANCE    hInstance;
 748   LPWSTR        lpszStyle;
 749   WORD         nFontType;
 750   WORD         ___MISSING_ALIGNMENT__;
 751   INT          nSizeMin;
 752   INT          nSizeMax;
 753 } CHOOSEFONTW, *LPCHOOSEFONTW;
 754
 755 typedef_tident(CHOOSEFONT)
 756 typedef_tident(LPCHOOSEFONT)
 757
 758 typedef struct _IDA {
 759   UINT cidl;
 760   UINT aoffset[1];
 761 } CIDA, * LPIDA;
 762
 763 typedef struct tagCLIENTCREATESTRUCT {
 764   HANDLE hWindowMenu;
 765   UINT   idFirstChild;
 766 } CLIENTCREATESTRUCT;
 767
 768 typedef CLIENTCREATESTRUCT *LPCLIENTCREATESTRUCT;
 769
 770 typedef struct _CMInvokeCommandInfo {
 771   DWORD cbSize;
 772   DWORD fMask;
 773   HWND hwnd;
 774   LPCSTR lpVerb;
 775   LPCSTR lpParameters;
 776   LPCSTR lpDirectory;
 777   int nShow;
 778   DWORD dwHotKey;
 779   HANDLE hIcon;
 780 } CMINVOKECOMMANDINFO, *LPCMINVOKECOMMANDINFO;
 781
 782 typedef struct  tagCOLORADJUSTMENT {
 783   WORD  caSize;
 784   WORD  caFlags;
 785   WORD  caIlluminantIndex;
 786   WORD  caRedGamma;
 787   WORD  caGreenGamma;
 788   WORD  caBlueGamma;
 789   WORD  caReferenceBlack;
 790   WORD  caReferenceWhite;
 791   SHORT caContrast;
 792   SHORT caBrightness;
 793   SHORT caColorfulness;
 794   SHORT caRedGreenTint;
 795 } COLORADJUSTMENT, *LPCOLORADJUSTMENT;
 796
 797 typedef struct _COLORMAP {
 798   COLORREF from;
 799   COLORREF to;
 800 } COLORMAP,  * LPCOLORMAP;
 801
 802 typedef struct _DCB {
 803   DWORD DCBlength;
 804   DWORD BaudRate;
 805   DWORD fBinary: 1;
 806   DWORD fParity: 1;
 807   DWORD fOutxCtsFlow:1;
 808   DWORD fOutxDsrFlow:1;
 809   DWORD fDtrControl:2;
 810   DWORD fDsrSensitivity:1;
 811   DWORD fTXContinueOnXoff:1;
 812   DWORD fOutX: 1;
 813   DWORD fInX: 1;
 814   DWORD fErrorChar: 1;
 815   DWORD fNull: 1;
 816   DWORD fRtsControl:2;
 817   DWORD fAbortOnError:1;
 818   DWORD fDummy2:17;
 819   WORD wReserved;
 820   WORD XonLim;
 821   WORD XoffLim;
 822   BYTE ByteSize;
 823   BYTE Parity;
 824   BYTE StopBits;
 825   char XonChar;
 826   char XoffChar;
 827   char ErrorChar;
 828   char EofChar;
 829   char EvtChar;
 830   WORD wReserved1;
 831 } DCB, *LPDCB;
 832
 833 typedef struct _COMM_CONFIG {
 834   DWORD dwSize;
 835   WORD  wVersion;
 836   WORD  wReserved;
 837   DCB   dcb;
 838   DWORD dwProviderSubType;
 839   DWORD dwProviderOffset;
 840   DWORD dwProviderSize;
 841   WCHAR wcProviderData[1];
 842 } COMMCONFIG, *LPCOMMCONFIG;
 843
 844 typedef struct _COMMPROP {
 845   WORD  wPacketLength;
 846   WORD  wPacketVersion;
 847   DWORD dwServiceMask;
 848   DWORD dwReserved1;
 849   DWORD dwMaxTxQueue;
 850   DWORD dwMaxRxQueue;
 851   DWORD dwMaxBaud;
 852   DWORD dwProvSubType;
 853   DWORD dwProvCapabilities;
 854   DWORD dwSettableParams;
 855   DWORD dwSettableBaud;
 856   WORD  wSettableData;
 857   WORD  wSettableStopParity;
 858   DWORD dwCurrentTxQueue;
 859   DWORD dwCurrentRxQueue;
 860   DWORD dwProvSpec1;
 861   DWORD dwProvSpec2;
 862   WCHAR wcProvChar[1];
 863 } COMMPROP, *LPCOMMPROP;
 864
 865 typedef struct _COMMTIMEOUTS {
 866   DWORD ReadIntervalTimeout;
 867   DWORD ReadTotalTimeoutMultiplier;
 868   DWORD ReadTotalTimeoutConstant;
 869   DWORD WriteTotalTimeoutMultiplier;
 870   DWORD WriteTotalTimeoutConstant;
 871 } COMMTIMEOUTS,*LPCOMMTIMEOUTS;
 872
 873 typedef struct tagCOMPAREITEMSTRUCT {
 874         UINT    CtlType;
 875         UINT    CtlID;
 876         HWND    hwndItem;
 877         UINT    itemID1;
 878         DWORD   itemData1;
 879         UINT    itemID2;
 880         DWORD   itemData2;
 881         DWORD   dwLocaleId;
 882 } COMPAREITEMSTRUCT,*LPCOMPAREITEMSTRUCT;
 883
 884
 885 typedef struct {
 886   COLORREF crText;
 887   COLORREF crBackground;
 888   DWORD dwEffects;
 889 } COMPCOLOR;
 890
 891 typedef struct _tagCOMPOSITIONFORM {
 892   DWORD  dwStyle;
 893   POINT  ptCurrentPos;
 894   RECT   rcArea;
 895 } COMPOSITIONFORM, *LPCOMPOSITIONFORM;
 896
 897 typedef struct _COMSTAT {
 898   DWORD fCtsHold : 1;
 899   DWORD fDsrHold : 1;
 900   DWORD fRlsdHold : 1;
 901   DWORD fXoffHold : 1;
 902   DWORD fXoffSent : 1;
 903   DWORD fEof : 1;
 904   DWORD fTxim : 1;
 905   DWORD fReserved : 25;
 906   DWORD cbInQue;
 907   DWORD cbOutQue;
 908 } COMSTAT, *LPCOMSTAT;
 909
 910 typedef struct tagCONVCONTEXT {
 911   UINT  cb;
 912   UINT  wFlags;
 913   UINT  wCountryID;
 914   int   iCodePage;
 915   DWORD dwLangID;
 916   DWORD dwSecurity;
 917   SECURITY_QUALITY_OF_SERVICE qos;
 918 } CONVCONTEXT;
 919
 920 typedef CONVCONTEXT *PCONVCONTEXT;
 921
 922 typedef struct tagCONVINFO {
 923   DWORD       cb;
 924   DWORD       hUser;
 925   HCONV       hConvPartner;
 926   HSZ         hszSvcPartner;
 927   HSZ         hszServiceReq;
 928   HSZ         hszTopic;
 929   HSZ         hszItem;
 930   UINT        wFmt;
 931   UINT        wType;
 932   UINT        wStatus;
 933   UINT        wConvst;
 934   UINT        wLastError;
 935   HCONVLIST   hConvList;
 936   CONVCONTEXT ConvCtxt;
 937   HWND        hwnd;
 938   HWND        hwndPartner;
 939 } CONVINFO, *PCONVINFO;
 940
 941 typedef struct tagCOPYDATASTRUCT {
 942   DWORD dwData;
 943   DWORD cbData;
 944   PVOID lpData;
 945 } COPYDATASTRUCT;
 946
 947 typedef struct tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA {
 948     PVOID lpInformation;
 949     PVOID lpSectionBase;
 950     ULONG ulSectionLength;
 951     PVOID lpSectionGlobalDataBase;
 952     ULONG ulSectionGlobalDataLength;
 953 } ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, *PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
 954 typedef const ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA *PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
 955
 956 typedef struct tagACTCTX_SECTION_KEYED_DATA {
 957     ULONG cbSize;
 958     ULONG ulDataFormatVersion;
 959     PVOID lpData;
 960     ULONG ulLength;
 961     PVOID lpSectionGlobalData;
 962     ULONG ulSectionGlobalDataLength;
 963     PVOID lpSectionBase;
 964     ULONG ulSectionTotalLength;
 965     HANDLE hActCtx;
 966     ULONG ulAssemblyRosterIndex;
 967 // 2600 stops here
 968     ULONG ulFlags;
 969     ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA AssemblyMetadata;
 970 } ACTCTX_SECTION_KEYED_DATA, *PACTCTX_SECTION_KEYED_DATA;
 971 typedef const ACTCTX_SECTION_KEYED_DATA * PCACTCTX_SECTION_KEYED_DATA;
 972
 973 typedef struct _cpinfo {
 974   UINT MaxCharSize;
 975   BYTE DefaultChar[MAX_DEFAULTCHAR];
 976   BYTE LeadByte[MAX_LEADBYTES];
 977 } CPINFO, *LPCPINFO;
 978
 979 typedef struct tagCPLINFO {
 980   int  idIcon;
 981   int  idName;
 982   int  idInfo;
 983   LONG lData;
 984 } CPLINFO;
 985
 986 typedef struct _CREATE_PROCESS_DEBUG_INFO {
 987   HANDLE hFile;
 988   HANDLE hProcess;
 989   HANDLE hThread;
 990   LPVOID lpBaseOfImage;
 991   DWORD dwDebugInfoFileOffset;
 992   DWORD nDebugInfoSize;
 993   LPVOID lpThreadLocalBase;
 994   LPTHREAD_START_ROUTINE lpStartAddress;
 995   LPVOID lpImageName;
 996   WORD fUnicode;
 997 } CREATE_PROCESS_DEBUG_INFO;
 998
 999 typedef struct _CREATE_THREAD_DEBUG_INFO {
1000   HANDLE hThread;
1001   LPVOID lpThreadLocalBase;
1002   LPTHREAD_START_ROUTINE lpStartAddress;
1003 } CREATE_THREAD_DEBUG_INFO;
1004
1005 /*
1006  TODO: sockets
1007 typedef struct _SOCKET_ADDRESS {
1008   LPSOCKADDR lpSockaddr ;
1009   INT iSockaddrLength ;
1010 } SOCKET_ADDRESS, *PSOCKET_ADDRESS, *LPSOCKET_ADDRESS;
1011 */
1012
1013 /*
1014 typedef struct _CSADDR_INFO {
1015   SOCKET_ADDRESS  LocalAddr;
1016   SOCKET_ADDRESS  RemoteAddr;
1017   INT             iSocketType;
1018   INT             iProtocol;
1019 } CSADDR_INFO;
1020 */
1021
1022 typedef struct {
1023     UINT cbSize;
1024     HDESK hdesk;
1025     HWND hwnd;
1026     LUID luid;
1027 } BSMINFO, *PBSMINFO;
1028
1029 typedef struct _currencyfmtA {
1030   UINT      NumDigits;
1031   UINT      LeadingZero;
1032   UINT      Grouping;
1033   LPSTR     lpDecimalSep;
1034   LPSTR     lpThousandSep;
1035   UINT      NegativeOrder;
1036   UINT      PositiveOrder;
1037   LPSTR     lpCurrencySymbol;
1038 } CURRENCYFMTA;
1039
1040 typedef struct _currencyfmtW {
1041   UINT      NumDigits;
1042   UINT      LeadingZero;
1043   UINT      Grouping;
1044   LPWSTR    lpDecimalSep;
1045   LPWSTR    lpThousandSep;
1046   UINT      NegativeOrder;
1047   UINT      PositiveOrder;
1048   LPWSTR    lpCurrencySymbol;
1049 } CURRENCYFMTW;
1050
1051 typedef_tident(CURRENCYFMT)
1052
1053 typedef struct _SERVICE_DESCRIPTIONA {
1054     LPSTR       lpDescription;
1055 } SERVICE_DESCRIPTIONA, *LPSERVICE_DESCRIPTIONA;
1056 typedef struct _SERVICE_DESCRIPTIONW {
1057     LPWSTR      lpDescription;
1058 } SERVICE_DESCRIPTIONW, *LPSERVICE_DESCRIPTIONW;
1059 typedef_tident(SERVICE_DESCRIPTION)
1060 typedef_tident(LPSERVICE_DESCRIPTION)
1061
1062 typedef enum _SC_ACTION_TYPE {
1063     SC_ACTION_NONE = 0,
1064     SC_ACTION_RESTART = 1,
1065     SC_ACTION_REBOOT = 2,
1066     SC_ACTION_RUN_COMMAND = 3
1067 } SC_ACTION_TYPE;
1068
1069 typedef struct _SC_ACTION {
1070     SC_ACTION_TYPE  Type;
1071     DWORD           Delay;
1072 } SC_ACTION, *LPSC_ACTION;
1073
1074 typedef struct _SERVICE_FAILURE_ACTIONSA {
1075     DWORD       dwResetPeriod;
1076     LPSTR       lpRebootMsg;
1077     LPSTR       lpCommand;
1078     DWORD       cActions;
1079     SC_ACTION * lpsaActions;
1080 } SERVICE_FAILURE_ACTIONSA, *LPSERVICE_FAILURE_ACTIONSA;
1081
1082 typedef struct _SERVICE_FAILURE_ACTIONSW {
1083     DWORD       dwResetPeriod;
1084     LPWSTR      lpRebootMsg;
1085     LPWSTR      lpCommand;
1086     DWORD       cActions;
1087     SC_ACTION * lpsaActions;
1088 } SERVICE_FAILURE_ACTIONSW, *LPSERVICE_FAILURE_ACTIONSW;
1089
1090 typedef_tident(SERVICE_FAILURE_ACTIONS)
1091 typedef_tident(LPSERVICE_FAILURE_ACTIONS)
1092
1093 typedef struct tagACTCTXA {
1094     ULONG       cbSize;
1095     DWORD       dwFlags;
1096     LPCSTR      lpSource;
1097     USHORT      wProcessorArchitecture;
1098     LANGID      wLangId;
1099     LPCSTR      lpAssemblyDirectory;
1100     LPCSTR      lpResourceName;
1101     LPCSTR      lpApplicationName;
1102     HMODULE     hModule;
1103 } ACTCTXA, *PACTCTXA;
1104
1105 typedef struct tagACTCTXW {
1106     ULONG       cbSize;
1107     DWORD       dwFlags;
1108     LPCWSTR     lpSource;
1109     USHORT      wProcessorArchitecture;
1110     LANGID      wLangId;
1111     LPCWSTR     lpAssemblyDirectory;
1112     LPCWSTR     lpResourceName;
1113     LPCWSTR     lpApplicationName;
1114     HMODULE     hModule;
1115 } ACTCTXW, *PACTCTXW;
1116
1117 typedef struct _JOB_SET_ARRAY {
1118     HANDLE JobHandle;
1119     DWORD MemberLevel;
1120     DWORD Flags;
1121 } JOB_SET_ARRAY, *PJOB_SET_ARRAY;
1122
1123 typedef struct _MEMORYSTATUSEX {
1124     DWORD dwLength;
1125     DWORD dwMemoryLoad;
1126     DWORDLONG ullTotalPhys;
1127     DWORDLONG ullAvailPhys;
1128     DWORDLONG ullTotalPageFile;
1129     DWORDLONG ullAvailPageFile;
1130     DWORDLONG ullTotalVirtual;
1131     DWORDLONG ullAvailVirtual;
1132     DWORDLONG ullAvailExtendedVirtual;
1133 } MEMORYSTATUSEX, *LPMEMORYSTATUSEX;
1134
1135 typedef const ACTCTXA *PCACTCTXA;
1136 typedef const ACTCTXW *PCACTCTXW;
1137 typedef_tident(ACTCTX)
1138 typedef_tident(PACTCTX)
1139
1140 typedef struct _TRIVERTEX
1141 {
1142     LONG    x;
1143     LONG    y;
1144     COLOR16 Red;
1145     COLOR16 Green;
1146     COLOR16 Blue;
1147     COLOR16 Alpha;
1148 }TRIVERTEX,*PTRIVERTEX,*LPTRIVERTEX;
1149
1150 typedef struct tagCURSORSHAPE {
1151   int     xHotSpot;
1152   int     yHotSpot;
1153   int     cx;
1154   int     cy;
1155   int     cbWidth;
1156   BYTE    Planes;
1157   BYTE    BitsPixel;
1158 } CURSORSHAPE,   *LPCURSORSHAPE;
1159
1160 typedef struct tagCWPRETSTRUCT {
1161   LRESULT lResult;
1162   LPARAM  lParam;
1163   WPARAM  wParam;
1164   DWORD   message;
1165   HWND    hwnd;
1166 } CWPRETSTRUCT;
1167
1168 typedef struct tagCWPSTRUCT {
1169   LPARAM  lParam;
1170   WPARAM  wParam;
1171   UINT    message;
1172   HWND    hwnd;
1173 } CWPSTRUCT;
1174
1175 typedef struct _DATATYPES_INFO_1A {
1176   LPSTR  pName;
1177 } DATATYPES_INFO_1A;
1178
1179 typedef struct _DATATYPES_INFO_1W {
1180   LPWSTR pName;
1181 } DATATYPES_INFO_1W;
1182
1183 typedef_tident(DATATYPES_INFO_1)
1184
1185 typedef struct {
1186   unsigned short bAppReturnCode:8,
1187     reserved:6,
1188     fBusy:1,
1189     fAck:1;
1190 } DDEACK;
1191
1192 typedef struct {
1193   unsigned short reserved:14,
1194     fDeferUpd:1,
1195     fAckReq:1;
1196   short cfFormat;
1197 } DDEADVISE;
1198
1199 typedef struct {
1200   unsigned short unused:12,
1201     fResponse:1,
1202     fRelease:1,
1203     reserved:1,
1204     fAckReq:1;
1205   short cfFormat;
1206   BYTE  Value[1];
1207 } DDEDATA;
1208
1209 typedef struct {
1210   unsigned short unused:13,
1211     fRelease:1,
1212     fDeferUpd:1,
1213     fAckReq:1;
1214   short cfFormat;
1215 } DDELN;
1216
1217 typedef struct tagDDEML_MSG_HOOK_DATA {
1218   UINT  uiLo;
1219   UINT  uiHi;
1220   DWORD cbData;
1221   DWORD Data[8];
1222 } DDEML_MSG_HOOK_DATA;
1223
1224 typedef struct {
1225   unsigned short unused:13,
1226     fRelease:1,
1227     fReserved:2;
1228   short cfFormat;
1229   BYTE  Value[1];
1230 } DDEPOKE;
1231
1232 typedef struct {
1233   unsigned short unused:12,
1234     fAck:1,
1235     fRelease:1,
1236     fReserved:1,
1237     fAckReq:1;
1238   short cfFormat;
1239   BYTE rgb[1];
1240 } DDEUP;
1241
1242 typedef struct _EXCEPTION_DEBUG_INFO {
1243   EXCEPTION_RECORD ExceptionRecord;
1244   DWORD dwFirstChance;
1245 } EXCEPTION_DEBUG_INFO;
1246
1247 typedef struct _EXIT_PROCESS_DEBUG_INFO {
1248   DWORD dwExitCode;
1249 } EXIT_PROCESS_DEBUG_INFO;
1250
1251 typedef struct _EXIT_THREAD_DEBUG_INFO {
1252   DWORD dwExitCode;
1253 } EXIT_THREAD_DEBUG_INFO;
1254
1255 typedef struct _LOAD_DLL_DEBUG_INFO {
1256   HANDLE hFile;
1257   LPVOID lpBaseOfDll;
1258   DWORD  dwDebugInfoFileOffset;
1259   DWORD  nDebugInfoSize;
1260   LPVOID lpImageName;
1261   WORD fUnicode;
1262 } LOAD_DLL_DEBUG_INFO;
1263
1264 typedef struct _UNLOAD_DLL_DEBUG_INFO {
1265   LPVOID lpBaseOfDll;
1266 } UNLOAD_DLL_DEBUG_INFO;
1267
1268 typedef struct _OUTPUT_DEBUG_STRING_INFO {
1269   LPSTR lpDebugStringData;
1270   WORD  fUnicode;
1271   WORD  nDebugStringLength;
1272 } OUTPUT_DEBUG_STRING_INFO;
1273
1274 typedef struct _RIP_INFO {
1275   DWORD  dwError;
1276   DWORD  dwType;
1277 } RIP_INFO;
1278
1279 typedef struct _DEBUG_EVENT {
1280   DWORD dwDebugEventCode;
1281   DWORD dwProcessId;
1282   DWORD dwThreadId;
1283   union {
1284     EXCEPTION_DEBUG_INFO Exception;
1285     CREATE_THREAD_DEBUG_INFO CreateThread;
1286     CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
1287     EXIT_THREAD_DEBUG_INFO ExitThread;
1288     EXIT_PROCESS_DEBUG_INFO ExitProcess;
1289     LOAD_DLL_DEBUG_INFO LoadDll;
1290     UNLOAD_DLL_DEBUG_INFO UnloadDll;
1291     OUTPUT_DEBUG_STRING_INFO DebugString;
1292     RIP_INFO RipInfo;
1293   } u;
1294 } DEBUG_EVENT, *LPDEBUG_EVENT;
1295
1296 typedef struct tagDEBUGHOOKINFO {
1297   DWORD  idThread;
1298   DWORD  idThreadInstaller;
1299   LPARAM lParam;
1300   WPARAM wParam;
1301   int    code;
1302 } DEBUGHOOKINFO;
1303
1304 typedef struct tagDELETEITEMSTRUCT {
1305   UINT CtlType;
1306   UINT CtlID;
1307   UINT itemID;
1308   HWND hwndItem;
1309   UINT itemData;
1310 } DELETEITEMSTRUCT;
1311
1312 typedef struct _DEV_BROADCAST_HDR {
1313   ULONG dbch_size;
1314   ULONG dbch_devicetype;
1315   ULONG dbch_reserved;
1316 } DEV_BROADCAST_HDR;
1317 typedef DEV_BROADCAST_HDR *PDEV_BROADCAST_HDR;
1318
1319 typedef struct _DEV_BROADCAST_OEM {
1320   ULONG dbco_size;
1321   ULONG dbco_devicetype;
1322   ULONG dbco_reserved;
1323   ULONG dbco_identifier;
1324   ULONG dbco_suppfunc;
1325 } DEV_BROADCAST_OEM;
1326 typedef DEV_BROADCAST_OEM *PDEV_BROADCAST_OEM;
1327
1328 typedef struct _DEV_BROADCAST_PORT {
1329   ULONG dbcp_size;
1330   ULONG dbcp_devicetype;
1331   ULONG dbcp_reserved;
1332   char dbcp_name[1];
1333 } DEV_BROADCAST_PORT;
1334 typedef DEV_BROADCAST_PORT *PDEV_BROADCAST_PORT;
1335
1336 struct _DEV_BROADCAST_USERDEFINED {
1337   struct _DEV_BROADCAST_HDR dbud_dbh;
1338   char  dbud_szName[1];
1339   BYTE  dbud_rgbUserDefined[1];
1340 };
1341
1342 typedef struct _DEV_BROADCAST_VOLUME {
1343   ULONG dbcv_size;
1344   ULONG dbcv_devicetype;
1345   ULONG dbcv_reserved;
1346   ULONG dbcv_unitmask;
1347   USHORT dbcv_flags;
1348 } DEV_BROADCAST_VOLUME;
1349 typedef DEV_BROADCAST_VOLUME *PDEV_BROADCAST_VOLUME;
1350
1351 typedef struct tagDEVNAMES {
1352   WORD wDriverOffset;
1353   WORD wDeviceOffset;
1354   WORD wOutputOffset;
1355   WORD wDefault;
1356 } DEVNAMES, *LPDEVNAMES;
1357
1358 typedef struct tagDIBSECTION {
1359   BITMAP              dsBm;
1360   BITMAPINFOHEADER    dsBmih;
1361   DWORD               dsBitfields[3];
1362   HANDLE              dshSection;
1363   DWORD               dsOffset;
1364 } DIBSECTION;
1365
1366 typedef struct _DISK_PERFORMANCE {
1367   LARGE_INTEGER BytesRead;
1368   LARGE_INTEGER BytesWritten;
1369   LARGE_INTEGER ReadTime;
1370   LARGE_INTEGER WriteTime;
1371   DWORD ReadCount;
1372   DWORD WriteCount;
1373   DWORD QueueDepth;
1374 } DISK_PERFORMANCE ;
1375
1376
1377 #include <pshpack1.h>
1378
1379 typedef struct {
1380   DWORD style;
1381   DWORD dwExtendedStyle;
1382   short x;
1383   short y;
1384   short cx;
1385   short cy;
1386   WORD  id;
1387 } DLGITEMTEMPLATE;
1388
1389 typedef DLGITEMTEMPLATE *LPDLGITEMTEMPLATE;
1390 typedef DLGITEMTEMPLATE *PDLGITEMTEMPLATE;
1391
1392 typedef struct {
1393   DWORD style;
1394   DWORD dwExtendedStyle;
1395   WORD  cdit;
1396   short x;
1397   short y;
1398   short cx;
1399   short cy;
1400 } DLGTEMPLATE;
1401
1402 #include <poppack.h>
1403
1404
1405 typedef DLGTEMPLATE *LPDLGTEMPLATE;
1406 typedef const DLGTEMPLATE *LPCDLGTEMPLATE;
1407
1408 typedef struct _DOC_INFO_1A {
1409   LPSTR  pDocName;
1410   LPSTR  pOutputFile;
1411   LPSTR  pDatatype;
1412 } DOC_INFO_1A;
1413
1414 typedef struct _DOC_INFO_1W {
1415   LPWSTR pDocName;
1416   LPWSTR pOutputFile;
1417   LPWSTR pDatatype;
1418 } DOC_INFO_1W;
1419
1420 typedef_tident(DOC_INFO_1)
1421
1422 typedef struct _DOC_INFO_2A {
1423   LPSTR  pDocName;
1424   LPSTR  pOutputFile;
1425   LPSTR  pDatatype;
1426   DWORD  dwMode;
1427   DWORD  JobId;
1428 } DOC_INFO_2A;
1429
1430 typedef struct _DOC_INFO_2W {
1431   LPWSTR pDocName;
1432   LPWSTR pOutputFile;
1433   LPWSTR pDatatype;
1434   DWORD  dwMode;
1435   DWORD  JobId;
1436 } DOC_INFO_2W;
1437
1438 typedef_tident(DOC_INFO_2)
1439
1440 typedef struct {
1441   int     cbSize;
1442   LPCSTR  lpszDocName;
1443   LPCSTR  lpszOutput;
1444   LPCSTR  lpszDatatype;
1445   DWORD   fwType;
1446 } DOCINFOA, *PDOCINFOA;
1447
1448 typedef struct {
1449   int     cbSize;
1450   LPCWSTR lpszDocName;
1451   LPCWSTR lpszOutput;
1452   LPCWSTR lpszDatatype;
1453   DWORD   fwType;
1454 } DOCINFOW, *PDOCINFOW;
1455
1456 typedef_tident(DOCINFO)
1457 typedef_tident(PDOCINFO)
1458
1459 typedef struct {
1460   UINT uNotification;
1461   HWND hWnd;
1462   POINT ptCursor;
1463 } DRAGLISTINFO, *LPDRAGLISTINFO;
1464
1465 typedef struct tagDRAWITEMSTRUCT {
1466   UINT  CtlType;
1467   UINT  CtlID;
1468   UINT  itemID;
1469   UINT  itemAction;
1470   UINT  itemState;
1471   HWND  hwndItem;
1472   HDC   hDC;
1473   RECT  rcItem;
1474   DWORD itemData;
1475 } DRAWITEMSTRUCT, *LPDRAWITEMSTRUCT, *PDRAWITEMSTRUCT;
1476
1477 typedef struct {
1478   UINT cbSize;
1479   int  iTabLength;
1480   int  iLeftMargin;
1481   int  iRightMargin;
1482   UINT uiLengthDrawn;
1483 } DRAWTEXTPARAMS, *LPDRAWTEXTPARAMS;
1484
1485
1486
1487 typedef struct _EXTTEXTMETRIC
1488     {
1489     short   emSize;
1490     short   emPointSize;
1491     short   emOrientation;
1492     short   emMasterHeight;
1493     short   emMinScale;
1494     short   emMaxScale;
1495     short   emMasterUnits;
1496     short   emCapHeight;
1497     short   emXHeight;
1498     short   emLowerCaseAscent;
1499     short   emLowerCaseDescent;
1500     short   emSlant;
1501     short   emSuperScript;
1502     short   emSubScript;
1503     short   emSuperScriptSize;
1504     short   emSubScriptSize;
1505     short   emUnderlineOffset;
1506     short   emUnderlineWidth;
1507     short   emDoubleUpperUnderlineOffset;
1508     short   emDoubleLowerUnderlineOffset;
1509     short   emDoubleUpperUnderlineWidth;
1510     short   emDoubleLowerUnderlineWidth;
1511     short   emStrikeOutOffset;
1512     short   emStrikeOutWidth;
1513     WORD    emKernPairs;
1514     WORD    emKernTracks;
1515 } EXTTEXTMETRIC, *PEXTTEXTMETRIC;
1516
1517 typedef struct _DRIVER_INFO_1A {
1518   LPSTR  pName;
1519 } DRIVER_INFO_1A;
1520
1521 typedef struct _DRIVER_INFO_1W {
1522   LPWSTR pName;
1523 } DRIVER_INFO_1W;
1524
1525 typedef_tident(DRIVER_INFO_1)
1526
1527 typedef struct _DRIVER_INFO_2A {
1528   DWORD  cVersion;
1529   LPSTR  pName;
1530   LPSTR  pEnvironment;
1531   LPSTR  pDriverPath;
1532   LPSTR  pDataFile;
1533   LPSTR  pConfigFile;
1534 } DRIVER_INFO_2A;
1535
1536 typedef struct _DRIVER_INFO_2W {
1537   DWORD  cVersion;
1538   LPWSTR pName;
1539   LPWSTR pEnvironment;
1540   LPWSTR pDriverPath;
1541   LPWSTR pDataFile;
1542   LPWSTR pConfigFile;
1543 } DRIVER_INFO_2W;
1544
1545 typedef_tident(DRIVER_INFO_2)
1546
1547 typedef struct _DRIVER_INFO_3A {
1548   DWORD  cVersion;
1549   LPSTR  pName;
1550   LPSTR  pEnvironment;
1551   LPSTR  pDriverPath;
1552   LPSTR  pDataFile;
1553   LPSTR  pConfigFile;
1554   LPSTR  pHelpFile;
1555   LPSTR  pDependentFiles;
1556   LPSTR  pMonitorName;
1557   LPSTR  pDefaultDataType;
1558 } DRIVER_INFO_3A;
1559
1560 typedef struct _DRIVER_INFO_3W {
1561   DWORD  cVersion;
1562   LPWSTR pName;
1563   LPWSTR pEnvironment;
1564   LPWSTR pDriverPath;
1565   LPWSTR pDataFile;
1566   LPWSTR pConfigFile;
1567   LPWSTR pHelpFile;
1568   LPWSTR pDependentFiles;
1569   LPWSTR pMonitorName;
1570   LPWSTR pDefaultDataType;
1571 } DRIVER_INFO_3W;
1572
1573 typedef_tident(DRIVER_INFO_3)
1574
1575 typedef struct _editstream {
1576   DWORD dwCookie;
1577   DWORD dwError;
1578   EDITSTREAMCALLBACK pfnCallback;
1579 } EDITSTREAM;
1580
1581 typedef struct tagEMR
1582 {
1583   DWORD iType;
1584   DWORD nSize;
1585 } EMR, *PEMR;
1586
1587 typedef struct tagEMRANGLEARC
1588 {
1589   EMR     emr;
1590   POINTL  ptlCenter;
1591   DWORD   nRadius;
1592   FLOAT   eStartAngle;
1593   FLOAT   eSweepAngle;
1594 } EMRANGLEARC, *PEMRANGLEARC;
1595
1596 typedef struct tagEMRARC
1597 {
1598   EMR    emr;
1599   RECTL  rclBox;
1600   POINTL ptlStart;
1601   POINTL ptlEnd;
1602 } EMRARC,   *PEMRARC,
1603     EMRARCTO, *PEMRARCTO,
1604     EMRCHORD, *PEMRCHORD,
1605     EMRPIE,   *PEMRPIE;
1606
1607 typedef struct  _XFORM
1608 {
1609   FLOAT   eM11;
1610   FLOAT   eM12;
1611   FLOAT   eM21;
1612   FLOAT   eM22;
1613   FLOAT   eDx;
1614   FLOAT   eDy;
1615 } XFORM, *PXFORM, *LPXFORM;
1616
1617 typedef struct tagEMRBITBLT
1618 {
1619   EMR      emr;
1620   RECTL    rclBounds;
1621   LONG     xDest;
1622   LONG     yDest;
1623   LONG     cxDest;
1624   LONG     cyDest;
1625   DWORD    dwRop;
1626   LONG     xSrc;
1627   LONG     ySrc;
1628   XFORM    xformSrc;
1629   COLORREF crBkColorSrc;
1630   DWORD    iUsageSrc;
1631   DWORD    offBmiSrc;
1632   DWORD    offBitsSrc;
1633   DWORD    cbBitsSrc;
1634 } EMRBITBLT, *PEMRBITBLT;
1635
1636 typedef struct tagLOGBRUSH {
1637   UINT     lbStyle;
1638   COLORREF lbColor;
1639   LONG     lbHatch;
1640 } LOGBRUSH, *PLOGBRUSH;
1641
1642 typedef struct tagEMRCREATEBRUSHINDIRECT
1643 {
1644   EMR      emr;
1645   DWORD    ihBrush;
1646   LOGBRUSH lb;
1647 } EMRCREATEBRUSHINDIRECT, *PEMRCREATEBRUSHINDIRECT;
1648
1649 typedef LONG LCSCSTYPE;
1650 typedef LONG LCSGAMUTMATCH;
1651
1652 typedef struct tagLOGCOLORSPACEA {
1653   DWORD         lcsSignature;
1654   DWORD         lcsVersion;
1655   DWORD         lcsSize;
1656
1657   LCSCSTYPE     lcsCSType;
1658   LCSGAMUTMATCH lcsIntent;
1659   CIEXYZTRIPLE  lcsEndpoints;
1660   DWORD         lcsGammaRed;
1661   DWORD         lcsGammaGreen;
1662   DWORD         lcsGammaBlue;
1663   CHAR          lcsFilename[MAX_PATH];
1664 } LOGCOLORSPACEA, *LPLOGCOLORSPACEA;
1665
1666 typedef struct tagLOGCOLORSPACEW {
1667   DWORD         lcsSignature;
1668   DWORD         lcsVersion;
1669   DWORD         lcsSize;
1670
1671   LCSCSTYPE     lcsCSType;
1672   LCSGAMUTMATCH lcsIntent;
1673   CIEXYZTRIPLE  lcsEndpoints;
1674   DWORD         lcsGammaRed;
1675   DWORD         lcsGammaGreen;
1676   DWORD         lcsGammaBlue;
1677   WCHAR         lcsFilename[MAX_PATH];
1678 } LOGCOLORSPACEW, *LPLOGCOLORSPACEW;
1679
1680 typedef_tident(LOGCOLORSPACE)
1681
1682 typedef struct tagEMRCREATECOLORSPACEA
1683 {
1684   EMR            emr;
1685   DWORD          ihCS;
1686   LOGCOLORSPACEA lcs;
1687 } EMRCREATECOLORSPACEA, *PEMRCREATECOLORSPACEA;
1688
1689 typedef struct tagEMRCREATECOLORSPACEW
1690 {
1691   EMR            emr;
1692   DWORD          ihCS;
1693   LOGCOLORSPACEW lcs;
1694 } EMRCREATECOLORSPACEW, *PEMRCREATECOLORSPACEW;
1695
1696 typedef_tident(EMRCREATECOLORSPACE)
1697 typedef_tident(PEMRCREATECOLORSPACE)
1698
1699 typedef struct tagEMRCREATEDIBPATTERNBRUSHPT
1700 {
1701   EMR   emr;
1702   DWORD ihBrush;
1703   DWORD iUsage;
1704   DWORD offBmi;
1705   DWORD cbBmi;
1706   DWORD offBits;
1707   DWORD cbBits;
1708 } EMRCREATEDIBPATTERNBRUSHPT,
1709     PEMRCREATEDIBPATTERNBRUSHPT;
1710
1711 typedef struct tagEMRCREATEMONOBRUSH
1712 {
1713   EMR   emr;
1714   DWORD ihBrush;
1715   DWORD iUsage;
1716   DWORD offBmi;
1717   DWORD cbBmi;
1718   DWORD offBits;
1719   DWORD cbBits;
1720 } EMRCREATEMONOBRUSH, *PEMRCREATEMONOBRUSH;
1721
1722 typedef struct tagPALETTEENTRY {
1723   BYTE peRed;
1724   BYTE peGreen;
1725   BYTE peBlue;
1726   BYTE peFlags;
1727 } PALETTEENTRY, *LPPALETTEENTRY, *PPALETTEENTRY;
1728
1729 typedef struct tagLOGPALETTE {
1730   WORD         palVersion;
1731   WORD         palNumEntries;
1732   PALETTEENTRY palPalEntry[1];
1733 } LOGPALETTE, *LPLOGPALETTE, *PLOGPALETTE;
1734
1735 typedef struct tagEMRCREATEPALETTE
1736 {
1737   EMR        emr;
1738   DWORD      ihPal;
1739   LOGPALETTE lgpl;
1740 } EMRCREATEPALETTE, *PEMRCREATEPALETTE;
1741
1742 typedef struct tagLOGPEN {
1743   UINT     lopnStyle;
1744   POINT    lopnWidth;
1745   COLORREF lopnColor;
1746 } LOGPEN, *PLOGPEN;
1747
1748 typedef struct tagEMRCREATEPEN
1749 {
1750   EMR    emr;
1751   DWORD  ihPen;
1752   LOGPEN lopn;
1753 } EMRCREATEPEN, *PEMRCREATEPEN;
1754
1755 typedef struct tagEMRELLIPSE
1756 {
1757   EMR   emr;
1758   RECTL rclBox;
1759 } EMRELLIPSE,  *PEMRELLIPSE,
1760     EMRRECTANGLE, *PEMRRECTANGLE;
1761
1762 typedef struct tagEMREOF
1763 {
1764   EMR     emr;
1765   DWORD   nPalEntries;
1766   DWORD   offPalEntries;
1767   DWORD   nSizeLast;
1768 } EMREOF, *PEMREOF;
1769
1770 typedef struct tagEMREXCLUDECLIPRECT
1771 {
1772   EMR   emr;
1773   RECTL rclClip;
1774 } EMREXCLUDECLIPRECT,   *PEMREXCLUDECLIPRECT,
1775     EMRINTERSECTCLIPRECT, *PEMRINTERSECTCLIPRECT;
1776
1777 typedef struct tagPANOSE {
1778   BYTE bFamilyType;
1779   BYTE bSerifStyle;
1780   BYTE bWeight;
1781   BYTE bProportion;
1782   BYTE bContrast;
1783   BYTE bStrokeVariation;
1784   BYTE bArmStyle;
1785   BYTE bLetterform;
1786   BYTE bMidline;
1787   BYTE bXHeight;
1788 } PANOSE;
1789
1790 typedef struct tagEXTLOGFONTA {
1791     LOGFONTA elfLogFont;
1792     CHAR     elfFullName[LF_FULLFACESIZE];
1793     CHAR     elfStyle[LF_FACESIZE];
1794     DWORD    elfVersion;
1795     DWORD    elfStyleSize;
1796     DWORD    elfMatch;
1797     DWORD    elfReserved;
1798     BYTE     elfVendorId[ELF_VENDOR_SIZE];
1799     DWORD    elfCulture;
1800     PANOSE   elfPanose;
1801 } EXTLOGFONTA, *LPEXTLOGFONTA;
1802
1803 typedef struct tagEXTLOGFONTW {
1804     LOGFONTW elfLogFont;
1805     WCHAR    elfFullName[LF_FULLFACESIZE];
1806     WCHAR    elfStyle[LF_FACESIZE];
1807     DWORD    elfVersion;
1808     DWORD    elfStyleSize;
1809     DWORD    elfMatch;
1810     DWORD    elfReserved;
1811     BYTE     elfVendorId[ELF_VENDOR_SIZE];
1812     DWORD    elfCulture;
1813     PANOSE   elfPanose;
1814 } EXTLOGFONTW, *LPEXTLOGFONTW;
1815
1816 typedef_tident(EXTLOGFONT)
1817 typedef_tident(LPEXTLOGFONT)
1818
1819 typedef struct tagEMREXTCREATEFONTINDIRECTW
1820 {
1821   EMR         emr;
1822   DWORD       ihFont;
1823   EXTLOGFONTW elfw;
1824 } EMREXTCREATEFONTINDIRECTW,
1825     PEMREXTCREATEFONTINDIRECTW;
1826
1827 typedef struct tagEXTLOGPEN {
1828   UINT     elpPenStyle;
1829   UINT     elpWidth;
1830   UINT     elpBrushStyle;
1831   COLORREF elpColor;
1832   LONG     elpHatch;
1833   DWORD    elpNumEntries;
1834   DWORD    elpStyleEntry[1];
1835 } EXTLOGPEN;
1836
1837 typedef struct tagEMREXTCREATEPEN
1838 {
1839   EMR       emr;
1840   DWORD     ihPen;
1841   DWORD     offBmi;
1842   DWORD     cbBmi;
1843   DWORD     offBits;
1844   DWORD     cbBits;
1845   EXTLOGPEN elp;
1846 } EMREXTCREATEPEN, *PEMREXTCREATEPEN;
1847
1848 typedef struct tagEMREXTFLOODFILL
1849 {
1850   EMR     emr;
1851   POINTL  ptlStart;
1852   COLORREF crColor;
1853   DWORD   iMode;
1854 } EMREXTFLOODFILL, *PEMREXTFLOODFILL;
1855
1856 typedef struct tagEMREXTSELECTCLIPRGN
1857 {
1858   EMR   emr;
1859   DWORD cbRgnData;
1860   DWORD iMode;
1861   BYTE  RgnData[1];
1862 } EMREXTSELECTCLIPRGN, *PEMREXTSELECTCLIPRGN;
1863
1864 typedef struct tagEMRTEXT
1865 {
1866   POINTL ptlReference;
1867   DWORD  nChars;
1868   DWORD  offString;
1869   DWORD  fOptions;
1870   RECTL  rcl;
1871   DWORD  offDx;
1872 } EMRTEXT, *PEMRTEXT;
1873
1874 typedef struct tagEMREXTTEXTOUTA
1875 {
1876   EMR     emr;
1877   RECTL   rclBounds;
1878   DWORD   iGraphicsMode;
1879   FLOAT   exScale;
1880   FLOAT   eyScale;
1881   EMRTEXT emrtext;
1882 } EMREXTTEXTOUTA, *PEMREXTTEXTOUTA,
1883     EMREXTTEXTOUTW, *PEMREXTTEXTOUTW;
1884
1885 typedef struct tagEMRFILLPATH
1886 {
1887   EMR   emr;
1888   RECTL rclBounds;
1889 } EMRFILLPATH,          *PEMRFILLPATH,
1890     EMRSTROKEANDFILLPATH, *PEMRSTROKEANDFILLPATH,
1891     EMRSTROKEPATH,        *PEMRSTROKEPATH;
1892
1893 typedef struct tagEMRFILLRGN
1894 {
1895   EMR   emr;
1896   RECTL rclBounds;
1897   DWORD cbRgnData;
1898   DWORD ihBrush;
1899   BYTE  RgnData[1];
1900 } EMRFILLRGN, *PEMRFILLRGN;
1901
1902 typedef struct tagEMRFORMAT {
1903   DWORD   dSignature;
1904   DWORD   nVersion;
1905   DWORD   cbData;
1906   DWORD   offData;
1907 } EMRFORMAT;
1908
1909 typedef struct tagSIZE {
1910   LONG cx;
1911   LONG cy;
1912 } SIZE, *PSIZE, *LPSIZE, SIZEL, *PSIZEL, *LPSIZEL;
1913
1914 typedef struct tagEMRFRAMERGN
1915 {
1916   EMR   emr;
1917   RECTL rclBounds;
1918   DWORD cbRgnData;
1919   DWORD ihBrush;
1920   SIZEL szlStroke;
1921   BYTE  RgnData[1];
1922 } EMRFRAMERGN, *PEMRFRAMERGN;
1923
1924 typedef struct tagEMRGDICOMMENT
1925 {
1926   EMR   emr;
1927   DWORD cbData;
1928   BYTE  Data[1];
1929 } EMRGDICOMMENT, *PEMRGDICOMMENT;
1930
1931 typedef struct tagEMRINVERTRGN
1932 {
1933   EMR   emr;
1934   RECTL rclBounds;
1935   DWORD cbRgnData;
1936   BYTE  RgnData[1];
1937 } EMRINVERTRGN, *PEMRINVERTRGN,
1938     EMRPAINTRGN,  *PEMRPAINTRGN;
1939
1940 typedef struct tagEMRLINETO
1941 {
1942   EMR    emr;
1943   POINTL ptl;
1944 } EMRLINETO,   *PEMRLINETO,
1945     EMRMOVETOEX, *PEMRMOVETOEX;
1946
1947 typedef struct tagEMRMASKBLT
1948 {
1949   EMR     emr;
1950   RECTL   rclBounds;
1951   LONG    xDest;
1952   LONG    yDest;
1953   LONG    cxDest;
1954   LONG    cyDest;
1955   DWORD   dwRop;
1956   LONG    xSrc;
1957   LONG    ySrc;
1958   XFORM   xformSrc;
1959   COLORREF crBkColorSrc;
1960   DWORD   iUsageSrc;
1961   DWORD   offBmiSrc;
1962   DWORD   cbBmiSrc;
1963   DWORD   offBitsSrc;
1964   DWORD   cbBitsSrc;
1965   LONG    xMask;
1966   LONG    yMask;
1967   DWORD   iUsageMask;
1968   DWORD   offBmiMask;
1969   DWORD   cbBmiMask;
1970   DWORD   offBitsMask;
1971   DWORD   cbBitsMask;
1972 } EMRMASKBLT, *PEMRMASKBLT;
1973
1974 typedef struct tagEMRMODIFYWORLDTRANSFORM
1975 {
1976   EMR   emr;
1977   XFORM xform;
1978   DWORD iMode;
1979 } EMRMODIFYWORLDTRANSFORM,
1980     PEMRMODIFYWORLDTRANSFORM;
1981
1982 typedef struct tagEMROFFSETCLIPRGN
1983 {
1984   EMR    emr;
1985   POINTL ptlOffset;
1986 } EMROFFSETCLIPRGN, *PEMROFFSETCLIPRGN;
1987
1988 typedef struct tagEMRPLGBLT
1989 {
1990   EMR      emr;
1991   RECTL    rclBounds;
1992   POINTL   aptlDest[3];
1993   LONG    xSrc;
1994   LONG    ySrc;
1995   LONG     cxSrc;
1996   LONG     cySrc;
1997   XFORM   xformSrc;
1998   COLORREF crBkColorSrc;
1999   DWORD    iUsageSrc;
2000   DWORD    offBmiSrc;
2001   DWORD   cbBmiSrc;
2002   DWORD   offBitsSrc;
2003   DWORD   cbBitsSrc;
2004   LONG    xMask;
2005   LONG    yMask;
2006   DWORD   iUsageMask;
2007   DWORD   offBmiMask;
2008   DWORD   cbBmiMask;
2009   DWORD   offBitsMask;
2010   DWORD   cbBitsMask;
2011 } EMRPLGBLT, *PEMRPLGBLT;
2012
2013 typedef struct tagEMRPOLYDRAW
2014 {
2015   EMR    emr;
2016   RECTL  rclBounds;
2017   DWORD  cptl;
2018   POINTL aptl[1];
2019   BYTE   abTypes[1];
2020 } EMRPOLYDRAW, *PEMRPOLYDRAW;
2021
2022 typedef struct tagEMRPOLYDRAW16
2023 {
2024   EMR    emr;
2025   RECTL  rclBounds;
2026   DWORD  cpts;
2027   POINTS apts[1];
2028   BYTE   abTypes[1];
2029 } EMRPOLYDRAW16, *PEMRPOLYDRAW16;
2030
2031 typedef struct tagEMRPOLYLINE
2032 {
2033   EMR    emr;
2034   RECTL  rclBounds;
2035   DWORD  cptl;
2036   POINTL aptl[1];
2037 } EMRPOLYLINE,     *PEMRPOLYLINE,
2038     EMRPOLYBEZIER,   *PEMRPOLYBEZIER,
2039     EMRPOLYGON,      *PEMRPOLYGON,
2040     EMRPOLYBEZIERTO, *PEMRPOLYBEZIERTO,
2041     EMRPOLYLINETO,   *PEMRPOLYLINETO;
2042
2043 typedef struct tagEMRPOLYLINE16
2044 {
2045   EMR    emr;
2046   RECTL  rclBounds;
2047   DWORD  cpts;
2048   POINTL apts[1];
2049 } EMRPOLYLINE16,     *PEMRPOLYLINE16,
2050     EMRPOLYBEZIER16,   *PEMRPOLYBEZIER16,
2051     EMRPOLYGON16,      *PEMRPOLYGON16,
2052     EMRPOLYBEZIERTO16, *PEMRPOLYBEZIERTO16,
2053     EMRPOLYLINETO16,   *PEMRPOLYLINETO16;
2054
2055 typedef struct tagEMRPOLYPOLYLINE
2056 {
2057   EMR     emr;
2058   RECTL   rclBounds;
2059   DWORD   nPolys;
2060   DWORD   cptl;
2061   DWORD   aPolyCounts[1];
2062   POINTL  aptl[1];
2063 } EMRPOLYPOLYLINE, *PEMRPOLYPOLYLINE,
2064     EMRPOLYPOLYGON,  *PEMRPOLYPOLYGON;
2065
2066 typedef struct tagEMRPOLYPOLYLINE16
2067 {
2068   EMR     emr;
2069   RECTL   rclBounds;
2070   DWORD   nPolys;
2071   DWORD   cpts;
2072   DWORD   aPolyCounts[1];
2073   POINTS  apts[1];
2074 } EMRPOLYPOLYLINE16, *PEMRPOLYPOLYLINE16,
2075     EMRPOLYPOLYGON16,  *PEMRPOLYPOLYGON16;
2076
2077 typedef struct tagEMRPOLYTEXTOUTA
2078 {
2079   EMR     emr;
2080   RECTL   rclBounds;
2081   DWORD   iGraphicsMode;
2082   FLOAT   exScale;
2083   FLOAT   eyScale;
2084   LONG    cStrings;
2085   EMRTEXT aemrtext[1];
2086 } EMRPOLYTEXTOUTA, *PEMRPOLYTEXTOUTA,
2087     EMRPOLYTEXTOUTW, *PEMRPOLYTEXTOUTW;
2088
2089 typedef struct tagEMRRESIZEPALETTE
2090 {
2091   EMR   emr;
2092   DWORD ihPal;
2093   DWORD cEntries;
2094 } EMRRESIZEPALETTE, *PEMRRESIZEPALETTE;
2095
2096 typedef struct tagEMRRESTOREDC
2097 {
2098   EMR  emr;
2099   LONG iRelative;
2100 } EMRRESTOREDC, *PEMRRESTOREDC;
2101
2102 typedef struct tagEMRROUNDRECT
2103 {
2104   EMR   emr;
2105   RECTL rclBox;
2106   SIZEL szlCorner;
2107 } EMRROUNDRECT, *PEMRROUNDRECT;
2108
2109 typedef struct tagEMRSCALEVIEWPORTEXTEX
2110 {
2111   EMR  emr;
2112   LONG xNum;
2113   LONG xDenom;
2114   LONG yNum;
2115   LONG yDenom;
2116 } EMRSCALEVIEWPORTEXTEX, *PEMRSCALEVIEWPORTEXTEX,
2117     EMRSCALEWINDOWEXTEX,   *PEMRSCALEWINDOWEXTEX;
2118
2119 typedef struct tagEMRSELECTCOLORSPACE
2120 {
2121   EMR     emr;
2122   DWORD   ihCS;
2123 } EMRSELECTCOLORSPACE, *PEMRSELECTCOLORSPACE,
2124     EMRDELETECOLORSPACE, *PEMRDELETECOLORSPACE;
2125 typedef struct tagEMRSELECTOBJECT
2126 {
2127   EMR   emr;
2128   DWORD ihObject;
2129 } EMRSELECTOBJECT, *PEMRSELECTOBJECT,
2130     EMRDELETEOBJECT, *PEMRDELETEOBJECT;
2131
2132 typedef struct tagEMRSELECTPALETTE
2133 {
2134   EMR   emr;
2135   DWORD ihPal;
2136 } EMRSELECTPALETTE, *PEMRSELECTPALETTE;
2137
2138 typedef struct tagEMRSETARCDIRECTION
2139 {
2140   EMR   emr;
2141   DWORD iArcDirection;
2142 } EMRSETARCDIRECTION, *PEMRSETARCDIRECTION;
2143
2144 typedef struct tagEMRSETTEXTCOLOR
2145 {
2146   EMR      emr;
2147   COLORREF crColor;
2148 } EMRSETBKCOLOR,   *PEMRSETBKCOLOR,
2149     EMRSETTEXTCOLOR, *PEMRSETTEXTCOLOR;
2150
2151 typedef struct tagEMRSETCOLORADJUSTMENT
2152 {
2153   EMR  emr;
2154   COLORADJUSTMENT ColorAdjustment;
2155 } EMRSETCOLORADJUSTMENT, *PEMRSETCOLORADJUSTMENT;
2156
2157 typedef struct tagEMRSETDIBITSTODEVICE
2158 {
2159   EMR   emr;
2160   RECTL rclBounds;
2161   LONG  xDest;
2162   LONG  yDest;
2163   LONG  xSrc;
2164   LONG  ySrc;
2165   LONG  cxSrc;
2166   LONG  cySrc;
2167   DWORD offBmiSrc;
2168   DWORD cbBmiSrc;
2169   DWORD offBitsSrc;
2170   DWORD cbBitsSrc;
2171   DWORD iUsageSrc;
2172   DWORD iStartScan;
2173   DWORD cScans;
2174 } EMRSETDIBITSTODEVICE, *PEMRSETDIBITSTODEVICE;
2175
2176 typedef struct tagEMRSETMAPPERFLAGS
2177 {
2178   EMR   emr;
2179   DWORD dwFlags;
2180 } EMRSETMAPPERFLAGS, *PEMRSETMAPPERFLAGS;
2181
2182 typedef struct tagEMRSETMITERLIMIT
2183 {
2184   EMR   emr;
2185   FLOAT eMiterLimit;
2186 } EMRSETMITERLIMIT, *PEMRSETMITERLIMIT;
2187
2188 typedef struct tagEMRSETPALETTEENTRIES
2189 {
2190   EMR          emr;
2191   DWORD        ihPal;
2192   DWORD        iStart;
2193   DWORD        cEntries;
2194   PALETTEENTRY aPalEntries[1];
2195 } EMRSETPALETTEENTRIES, *PEMRSETPALETTEENTRIES;
2196
2197 typedef struct tagEMRSETPIXELV
2198 {
2199   EMR     emr;
2200   POINTL  ptlPixel;
2201   COLORREF crColor;
2202 } EMRSETPIXELV, *PEMRSETPIXELV;
2203
2204 typedef struct tagEMRSETVIEWPORTEXTEX
2205 {
2206   EMR   emr;
2207   SIZEL szlExtent;
2208 } EMRSETVIEWPORTEXTEX, *PEMRSETVIEWPORTEXTEX,
2209     EMRSETWINDOWEXTEX,   *PEMRSETWINDOWEXTEX;
2210
2211 typedef struct tagEMRSETVIEWPORTORGEX
2212 {
2213   EMR    emr;
2214   POINTL ptlOrigin;
2215 } EMRSETVIEWPORTORGEX, *PEMRSETVIEWPORTORGEX,
2216     EMRSETWINDOWORGEX,   *PEMRSETWINDOWORGEX,
2217     EMRSETBRUSHORGEX,    *PEMRSETBRUSHORGEX;
2218
2219 typedef struct tagEMRSETWORLDTRANSFORM
2220 {
2221   EMR   emr;
2222   XFORM xform;
2223 } EMRSETWORLDTRANSFORM, *PEMRSETWORLDTRANSFORM;
2224
2225 typedef struct tagEMRSTRETCHBLT
2226 {
2227   EMR      emr;
2228   RECTL    rclBounds;
2229   LONG     xDest;
2230   LONG     yDest;
2231   LONG     cxDest;
2232   LONG     cyDest;
2233   DWORD    dwRop;
2234   LONG     xSrc;
2235   LONG     ySrc;
2236   XFORM    xformSrc;
2237   COLORREF crBkColorSrc;
2238   DWORD    iUsageSrc;
2239   DWORD    offBmiSrc;
2240   DWORD    cbBmiSrc;
2241   DWORD    offBitsSrc;
2242   DWORD    cbBitsSrc;
2243   LONG     cxSrc;
2244   LONG     cySrc;
2245 } EMRSTRETCHBLT, *PEMRSTRETCHBLT;
2246
2247 typedef struct tagEMRSTRETCHDIBITS
2248 {
2249   EMR   emr;
2250   RECTL rclBounds;
2251   LONG  xDest;
2252   LONG  yDest;
2253   LONG  xSrc;
2254   LONG  ySrc;
2255   LONG  cxSrc;
2256   LONG  cySrc;
2257   DWORD offBmiSrc;
2258   DWORD cbBmiSrc;
2259   DWORD offBitsSrc;
2260   DWORD cbBitsSrc;
2261   DWORD iUsageSrc;
2262   DWORD dwRop;
2263   LONG  cxDest;
2264   LONG  cyDest;
2265 } EMRSTRETCHDIBITS, *PEMRSTRETCHDIBITS;
2266
2267 typedef struct tagABORTPATH
2268 {
2269   EMR emr;
2270 } EMRABORTPATH,      *PEMRABORTPATH,
2271     EMRBEGINPATH,      *PEMRBEGINPATH,
2272     EMRENDPATH,        *PEMRENDPATH,
2273     EMRCLOSEFIGURE,    *PEMRCLOSEFIGURE,
2274     EMRFLATTENPATH,    *PEMRFLATTENPATH,
2275     EMRWIDENPATH,      *PEMRWIDENPATH,
2276     EMRSETMETARGN,     *PEMRSETMETARGN,
2277     EMRSAVEDC,         *PEMRSAVEDC,
2278     EMRREALIZEPALETTE, *PEMRREALIZEPALETTE;
2279
2280 typedef struct tagEMRSELECTCLIPPATH
2281 {
2282   EMR   emr;
2283   DWORD iMode;
2284 } EMRSELECTCLIPPATH,    *PEMRSELECTCLIPPATH,
2285     EMRSETBKMODE,         *PEMRSETBKMODE,
2286     EMRSETMAPMODE,        *PEMRSETMAPMODE,
2287     EMRSETPOLYFILLMODE,   *PEMRSETPOLYFILLMODE,
2288     EMRSETROP2,           *PEMRSETROP2,
2289     EMRSETSTRETCHBLTMODE, *PEMRSETSTRETCHBLTMODE,
2290     EMRSETTEXTALIGN,      *PEMRSETTEXTALIGN,
2291     EMRENABLEICM,       *PEMRENABLEICM;
2292
2293 typedef struct tagNMHDR {
2294   HWND hwndFrom;
2295   UINT idFrom;
2296   UINT code;
2297 } NMHDR;
2298
2299 typedef struct _encorrecttext {
2300   NMHDR nmhdr;
2301   CHARRANGE chrg;
2302   WORD seltyp;
2303 } ENCORRECTTEXT;
2304
2305 typedef struct _endropfiles {
2306   NMHDR nmhdr;
2307   HANDLE hDrop;
2308   LONG cp;
2309   WINBOOL fProtected;
2310 } ENDROPFILES;
2311
2312 typedef struct {
2313   NMHDR nmhdr;
2314   LONG cObjectCount;
2315   LONG cch;
2316 } ENSAVECLIPBOARD;
2317
2318 typedef struct {
2319   NMHDR nmhdr;
2320   LONG iob;
2321   LONG lOper;
2322   HRESULT hr;
2323 } ENOLEOPFAILED;
2324
2325 typedef struct tagENHMETAHEADER {
2326   DWORD iType;
2327   DWORD nSize;
2328   RECTL rclBounds;
2329   RECTL rclFrame;
2330   DWORD dSignature;
2331   DWORD nVersion;
2332   DWORD nBytes;
2333   DWORD nRecords;
2334   WORD  nHandles;
2335   WORD  sReserved;
2336   DWORD nDescription;
2337   DWORD offDescription;
2338   DWORD nPalEntries;
2339   SIZEL szlDevice;
2340   SIZEL szlMillimeters;
2341   DWORD cbPixelFormat;
2342   DWORD offPixelFormat;
2343   DWORD bOpenGL;
2344   SIZEL szlMicrometers;
2345 } ENHMETAHEADER, *LPENHMETAHEADER;
2346
2347 typedef struct tagENHMETARECORD {
2348   DWORD iType;
2349   DWORD nSize;
2350   DWORD dParm[1];
2351 } ENHMETARECORD, *PENHMETARECORD, *LPENHMETARECORD;
2352
2353 typedef struct _enprotected {
2354   NMHDR nmhdr;
2355   UINT msg;
2356   WPARAM wParam;
2357   LPARAM lParam;
2358   CHARRANGE chrg;
2359 } ENPROTECTED;
2360
2361 typedef struct _SERVICE_STATUS {
2362   DWORD dwServiceType;
2363   DWORD dwCurrentState;
2364   DWORD dwControlsAccepted;
2365   DWORD dwWin32ExitCode;
2366   DWORD dwServiceSpecificExitCode;
2367   DWORD dwCheckPoint;
2368   DWORD dwWaitHint;
2369 } SERVICE_STATUS, *LPSERVICE_STATUS;
2370
2371 typedef struct _SERVICE_STATUS_PROCESS {
2372     DWORD   dwServiceType;
2373     DWORD   dwCurrentState;
2374     DWORD   dwControlsAccepted;
2375     DWORD   dwWin32ExitCode;
2376     DWORD   dwServiceSpecificExitCode;
2377     DWORD   dwCheckPoint;
2378     DWORD   dwWaitHint;
2379     DWORD   dwProcessId;
2380     DWORD   dwServiceFlags;
2381 } SERVICE_STATUS_PROCESS, *LPSERVICE_STATUS_PROCESS;
2382
2383 typedef struct _ENUM_SERVICE_STATUSA {
2384   LPSTR lpServiceName;
2385   LPSTR lpDisplayName;
2386   SERVICE_STATUS ServiceStatus;
2387 } ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA;
2388
2389 typedef struct _ENUM_SERVICE_STATUSW {
2390   LPWSTR lpServiceName;
2391   LPWSTR lpDisplayName;
2392   SERVICE_STATUS ServiceStatus;
2393 } ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;
2394
2395 typedef_tident(ENUM_SERVICE_STATUS)
2396 typedef_tident(LPENUM_SERVICE_STATUS)
2397
2398 typedef struct _ENUM_SERVICE_STATUS_PROCESSA {
2399     LPSTR                     lpServiceName;
2400     LPSTR                     lpDisplayName;
2401     SERVICE_STATUS_PROCESS    ServiceStatusProcess;
2402 } ENUM_SERVICE_STATUS_PROCESSA, *LPENUM_SERVICE_STATUS_PROCESSA;
2403
2404 typedef struct _ENUM_SERVICE_STATUS_PROCESSW {
2405     LPWSTR                    lpServiceName;
2406     LPWSTR                    lpDisplayName;
2407     SERVICE_STATUS_PROCESS    ServiceStatusProcess;
2408 } ENUM_SERVICE_STATUS_PROCESSW, *LPENUM_SERVICE_STATUS_PROCESSW;
2409
2410 typedef_tident(ENUM_SERVICE_STATUS_PROCESS)
2411 typedef_tident(LPENUM_SERVICE_STATUS_PROCESS)
2412
2413 typedef struct tagENUMLOGFONTA {
2414   LOGFONTA elfLogFont;
2415   CHAR     elfFullName[LF_FULLFACESIZE];
2416   CHAR     elfStyle[LF_FACESIZE];
2417 } ENUMLOGFONTA, *LPENUMLOGFONTA;
2418
2419 typedef struct tagENUMLOGFONTW {
2420   LOGFONTW elfLogFont;
2421   WCHAR    elfFullName[LF_FULLFACESIZE];
2422   WCHAR    elfStyle[LF_FACESIZE];
2423 } ENUMLOGFONTW, *LPENUMLOGFONTW;
2424
2425 typedef_tident(ENUMLOGFONT)
2426 typedef_tident(LPENUMLOGFONT)
2427
2428 typedef struct tagENUMLOGFONTEXA {
2429   LOGFONTA elfLogFont;
2430   CHAR     elfFullName[LF_FULLFACESIZE];
2431   CHAR     elfStyle[LF_FACESIZE];
2432   CHAR     elfScript[LF_FACESIZE];
2433 } ENUMLOGFONTEXA, *LPENUMLOGFONTEXA;
2434
2435 typedef struct tagENUMLOGFONTEXW {
2436   LOGFONTW elfLogFont;
2437   WCHAR    elfFullName[LF_FULLFACESIZE];
2438   WCHAR    elfStyle[LF_FACESIZE];
2439   WCHAR    elfScript[LF_FACESIZE];
2440 } ENUMLOGFONTEXW, *LPENUMLOGFONTEXW;
2441
2442 typedef_tident(ENUMLOGFONTEX)
2443 typedef_tident(LPENUMLOGFONTEX)
2444
2445 typedef struct tagDESIGNVECTOR
2446 {
2447     DWORD  dvReserved;
2448     DWORD  dvNumAxes;
2449     LONG   dvValues[MM_MAX_NUMAXES];
2450 } DESIGNVECTOR, *PDESIGNVECTOR, FAR *LPDESIGNVECTOR;
2451
2452 typedef struct tagENUMLOGFONTEXDVA
2453 {
2454     ENUMLOGFONTEXA elfEnumLogfontEx;
2455     DESIGNVECTOR   elfDesignVector;
2456 } ENUMLOGFONTEXDVA, *PENUMLOGFONTEXDVA, FAR *LPENUMLOGFONTEXDVA;
2457 typedef struct tagENUMLOGFONTEXDVW
2458 {
2459     ENUMLOGFONTEXW elfEnumLogfontEx;
2460     DESIGNVECTOR   elfDesignVector;
2461 } ENUMLOGFONTEXDVW, *PENUMLOGFONTEXDVW, FAR *LPENUMLOGFONTEXDVW;
2462
2463 typedef_tident(ENUMLOGFONTEXDV)
2464 typedef_tident(PENUMLOGFONTEXDV)
2465 typedef_tident(LPENUMLOGFONTEXDV)
2466
2467 typedef struct _EVENTLOGRECORD {
2468   DWORD  Length;
2469   DWORD  Reserved;
2470   DWORD  RecordNumber;
2471   DWORD  TimeGenerated;
2472   DWORD  TimeWritten;
2473   DWORD  EventID;
2474   WORD   EventType;
2475   WORD   NumStrings;
2476   WORD   EventCategory;
2477   WORD   ReservedFlags;
2478   DWORD  ClosingRecordNumber;
2479   DWORD  StringOffset;
2480   DWORD  UserSidLength;
2481   DWORD  UserSidOffset;
2482   DWORD  DataLength;
2483   DWORD  DataOffset;
2484
2485 /*
2486   Then follow:
2487
2488   TCHAR SourceName[]
2489   TCHAR Computername[]
2490   SID   UserSid
2491   TCHAR Strings[]
2492   BYTE  Data[]
2493   CHAR  Pad[]
2494   DWORD Length;
2495 */
2496
2497 } EVENTLOGRECORD;
2498
2499 typedef struct tagEVENTMSG {
2500   UINT  message;
2501   UINT  paramL;
2502   UINT  paramH;
2503   DWORD time;
2504   HWND  hwnd;
2505 } EVENTMSG;
2506
2507 typedef struct _EXT_BUTTON {
2508   WORD idCommand;
2509   WORD idsHelp;
2510   WORD fsStyle;
2511 } EXT_BUTTON, *LPEXT_BUTTON;
2512
2513 typedef struct tagFILTERKEYS {
2514   UINT  cbSize;
2515   DWORD dwFlags;
2516   DWORD iWaitMSec;
2517   DWORD iDelayMSec;
2518   DWORD iRepeatMSec;
2519   DWORD iBounceMSec;
2520 } FILTERKEYS;
2521
2522 typedef struct _FIND_NAME_BUFFER {
2523   UCHAR length;
2524   UCHAR access_control;
2525   UCHAR frame_control;
2526   UCHAR destination_addr[6];
2527   UCHAR source_addr[6];
2528   UCHAR routing_info[18];
2529 } FIND_NAME_BUFFER;
2530
2531 typedef struct _FIND_NAME_HEADER {
2532   WORD  node_count;
2533   UCHAR reserved;
2534   UCHAR unique_group;
2535 } FIND_NAME_HEADER;
2536
2537 typedef
2538 enum _FINDEX_INFO_LEVELS
2539 {
2540         FindExInfoStandard,
2541         FindExInfoMaxInfoLevel
2542 } FINDEX_INFO_LEVELS;
2543
2544 typedef
2545 enum _FINDEX_SEARCH_OPS
2546 {
2547         FindExSearchNameMatch,
2548         FindExSearchLimitToDirectories,
2549         FindExSearchLimitToDevices,
2550         FindExSearchMaxSearchOp
2551
2552 } FINDEX_SEARCH_OPS;
2553
2554 #define FIND_FIRST_EX_CASE_SENSITIVE   0x00000001
2555
2556 typedef struct {
2557   DWORD        lStructSize;
2558   HWND         hwndOwner;
2559   HINSTANCE    hInstance;
2560   DWORD        Flags;
2561   LPSTR        lpstrFindWhat;
2562   LPSTR        lpstrReplaceWith;
2563   WORD         wFindWhatLen;
2564   WORD         wReplaceWithLen;
2565   LPARAM       lCustData;
2566   LPFRHOOKPROC lpfnHook;
2567   LPCSTR       lpTemplateName;
2568 } FINDREPLACEA, *LPFINDREPLACEA;
2569
2570 typedef struct {
2571   DWORD        lStructSize;
2572   HWND         hwndOwner;
2573   HINSTANCE    hInstance;
2574   DWORD        Flags;
2575   LPWSTR       lpstrFindWhat;
2576   LPWSTR       lpstrReplaceWith;
2577   WORD         wFindWhatLen;
2578   WORD         wReplaceWithLen;
2579   LPARAM       lCustData;
2580   LPFRHOOKPROC lpfnHook;
2581   LPCWSTR      lpTemplateName;
2582 } FINDREPLACEW, *LPFINDREPLACEW;
2583
2584 typedef_tident(FINDREPLACE)
2585 typedef_tident(LPFINDREPLACE)
2586
2587 typedef struct _findtext {
2588   CHARRANGE chrg;
2589   LPSTR lpstrText;
2590 } FINDTEXT;
2591
2592 typedef struct _findtextex {
2593   CHARRANGE chrg;
2594   LPSTR lpstrText;
2595   CHARRANGE chrgText;
2596 } FINDTEXTEX;
2597
2598 typedef struct _FMS_GETDRIVEINFOA {
2599   DWORD dwTotalSpace;
2600   DWORD dwFreeSpace;
2601   CHAR   szPath[260];
2602   CHAR   szVolume[14];
2603   CHAR   szShare[128];
2604 } FMS_GETDRIVEINFOA;
2605
2606 typedef struct _FMS_GETDRIVEINFOW {
2607   DWORD dwTotalSpace;
2608   DWORD dwFreeSpace;
2609   WCHAR  szPath[260];
2610   WCHAR  szVolume[14];
2611   WCHAR  szShare[128];
2612 } FMS_GETDRIVEINFOW;
2613
2614 typedef_tident(FMS_GETDRIVEINFO)
2615
2616 typedef struct _FMS_GETFILESELA {
2617   FILETIME ftTime;
2618   DWORD    dwSize;
2619   BYTE     bAttr;
2620   CHAR     szName[260];
2621 } FMS_GETFILESELA;
2622
2623 typedef struct _FMS_GETFILESELW {
2624   FILETIME ftTime;
2625   DWORD    dwSize;
2626   BYTE     bAttr;
2627   WCHAR     szName[260];
2628 } FMS_GETFILESELW;
2629
2630 typedef_tident(FMS_GETFILESEL)
2631
2632 typedef struct _FMS_LOADA {
2633   DWORD dwSize;
2634   CHAR  szMenuName[MENU_TEXT_LEN];
2635   HMENU hMenu;
2636   UINT  wMenuDelta;
2637 } FMS_LOADA;
2638
2639 typedef struct _FMS_LOADW {
2640   DWORD dwSize;
2641   WCHAR  szMenuName[MENU_TEXT_LEN];
2642   HMENU hMenu;
2643   UINT  wMenuDelta;
2644 } FMS_LOADW;
2645
2646 typedef_tident(FMS_LOAD)
2647
2648 typedef struct _FMS_TOOLBARLOAD {
2649   DWORD        dwSize;
2650   LPEXT_BUTTON lpButtons;
2651   WORD         cButtons;
2652   WORD         cBitmaps;
2653   WORD         idBitmap;
2654   HBITMAP      hBitmap;
2655 } FMS_TOOLBARLOAD;
2656
2657
2658 typedef struct _FORM_INFO_1A {
2659   DWORD  Flags;
2660   LPSTR  pName;
2661   SIZEL  Size;
2662   RECTL  ImageableArea;
2663 } FORM_INFO_1A;
2664
2665 typedef struct _FORM_INFO_1W {
2666   DWORD  Flags;
2667   LPWSTR pName;
2668   SIZEL  Size;
2669   RECTL  ImageableArea;
2670 } FORM_INFO_1W;
2671
2672 typedef_tident(FORM_INFO_1)
2673
2674 typedef struct _FORMAT_PARAMETERS {
2675   MEDIA_TYPE MediaType;
2676   DWORD StartCylinderNumber;
2677   DWORD EndCylinderNumber;
2678   DWORD StartHeadNumber;
2679   DWORD EndHeadNumber;
2680 } FORMAT_PARAMETERS ;
2681
2682 typedef struct _formatrange {
2683   HDC hdc;
2684   HDC hdcTarget;
2685   RECT rc;
2686   RECT rcPage;
2687   CHARRANGE chrg;
2688 } FORMATRANGE;
2689
2690 typedef struct tagGCP_RESULTSA {
2691   DWORD  lStructSize;
2692   LPSTR  lpOutString;
2693   UINT  *lpOrder;
2694   INT  *lpDx;
2695   INT  *lpCaretPos;
2696   LPSTR lpClass;
2697   UINT  *lpGlyphs;
2698   UINT  nGlyphs;
2699   UINT  nMaxFit;
2700 } GCP_RESULTSA, *LPGCP_RESULTSA;
2701
2702 typedef struct tagGCP_RESULTSW {
2703   DWORD  lStructSize;
2704   LPWSTR  lpOutString;
2705   UINT  *lpOrder;
2706   INT  *lpDx;
2707   INT  *lpCaretPos;
2708   LPWSTR lpClass;
2709   UINT  *lpGlyphs;
2710   UINT  nGlyphs;
2711   UINT  nMaxFit;
2712 } GCP_RESULTSW, *LPGCP_RESULTSW;
2713
2714 typedef_tident(GCP_RESULTS)
2715
2716
2717 typedef struct _GLYPHMETRICS {
2718   UINT  gmBlackBoxX;
2719   UINT  gmBlackBoxY;
2720   POINT gmptGlyphOrigin;
2721   short gmCellIncX;
2722   short gmCellIncY;
2723 } GLYPHMETRICS, *LPGLYPHMETRICS;
2724
2725 typedef struct tagHANDLETABLE {
2726   HGDIOBJ objectHandle[1];
2727 } HANDLETABLE, *LPHANDLETABLE;
2728
2729 typedef struct _HD_HITTESTINFO {
2730   POINT pt;
2731   UINT flags;
2732   int iItem;
2733 } HD_HITTESTINFO;
2734
2735 typedef struct _HD_ITEMA {
2736   UINT    mask;
2737   int     cxy;
2738   LPSTR   pszText;
2739   HBITMAP hbm;
2740   int     cchTextMax;
2741   int     fmt;
2742   LPARAM  lParam;
2743 } HD_ITEMA;
2744
2745 typedef struct _HD_ITEMW {
2746   UINT    mask;
2747   int     cxy;
2748   LPWSTR  pszText;
2749   HBITMAP hbm;
2750   int     cchTextMax;
2751   int     fmt;
2752   LPARAM  lParam;
2753 } HD_ITEMW;
2754
2755 typedef_tident(HD_ITEM)
2756
2757 typedef struct _WINDOWPOS {
2758   HWND hwnd;
2759   HWND hwndInsertAfter;
2760   int  x;
2761   int  y;
2762   int  cx;
2763   int  cy;
2764   UINT flags;
2765 } WINDOWPOS, *PWINDOWPOS, *LPWINDOWPOS;
2766
2767 typedef struct _HD_LAYOUT {
2768   RECT  * prc;
2769   WINDOWPOS  * pwpos;
2770 } HD_LAYOUT;
2771
2772 typedef struct _HD_NOTIFYA {
2773   NMHDR     hdr;
2774   int       iItem;
2775   int       iButton;
2776   HD_ITEMA *pitem;
2777 } HD_NOTIFYA;
2778
2779 typedef struct _HD_NOTIFYW {
2780   NMHDR     hdr;
2781   int       iItem;
2782   int       iButton;
2783   HD_ITEMW *pitem;
2784 } HD_NOTIFYW;
2785
2786 typedef_tident(HD_NOTIFY)
2787
2788 typedef  struct  tagHELPINFO {
2789   UINT   cbSize;
2790   int    iContextType;
2791   int    iCtrlId;
2792   HANDLE hItemHandle;
2793   DWORD  dwContextId;
2794   POINT  MousePos;
2795 } HELPINFO,   *LPHELPINFO;
2796
2797 typedef struct tagMULTIKEYHELPA {
2798     DWORD   mkSize;
2799     CHAR    mkKeyList;
2800     CHAR    szKeyphrase[1];
2801 } MULTIKEYHELPA, *PMULTIKEYHELPA, *LPMULTIKEYHELPA;
2802
2803 typedef struct tagMULTIKEYHELPW {
2804     DWORD   mkSize;
2805     WCHAR   mkKeyList;
2806     WCHAR   szKeyphrase[1];
2807 } MULTIKEYHELPW, *PMULTIKEYHELPW, *LPMULTIKEYHELPW;
2808
2809 typedef_tident(MULTIKEYHELP)
2810 typedef_tident(PMULTIKEYHELP)
2811 typedef_tident(LPMULTIKEYHELP)
2812
2813 typedef struct {
2814         int wStructSize;
2815         int x;
2816         int y;
2817         int dx;
2818         int dy;
2819         int wMax;
2820         CHAR rgchMember[2];
2821 } HELPWININFOA, *PHELPWININFOA, *LPHELPWININFOA;
2822
2823 typedef struct {
2824         int wStructSize;
2825         int x;
2826         int y;
2827         int dx;
2828         int dy;
2829         int wMax;
2830         WCHAR rgchMember[2];
2831 } HELPWININFOW, *PHELPWININFOW, *LPHELPWININFOW;
2832
2833 typedef_tident(HELPWININFO)
2834 typedef_tident(PHELPWININFO)
2835 typedef_tident(LPHELPWININFO)
2836
2837 typedef struct tagHIGHCONTRASTA {
2838   UINT cbSize;
2839   DWORD dwFlags;
2840   LPSTR lpszDefaultScheme;
2841 } HIGHCONTRASTA, *LPHIGHCONTRASTA;
2842
2843 typedef struct tagHIGHCONTRASTW {
2844   UINT cbSize;
2845   DWORD dwFlags;
2846   LPWSTR lpszDefaultScheme;
2847 } HIGHCONTRASTW, *LPHIGHCONTRASTW;
2848
2849 typedef_tident(HIGHCONTRAST)
2850 typedef_tident(LPHIGHCONTRAST)
2851
2852 typedef struct tagHSZPAIR {
2853   HSZ hszSvc;
2854   HSZ hszTopic;
2855 } HSZPAIR;
2856
2857 typedef struct _ICONINFO {
2858   WINBOOL    fIcon;
2859   DWORD   xHotspot;
2860   DWORD   yHotspot;
2861   HBITMAP hbmMask;
2862   HBITMAP hbmColor;
2863 } ICONINFO, *PICONINFO;
2864
2865 typedef struct tagICONMETRICSA {
2866   UINT     cbSize;
2867   int      iHorzSpacing;
2868   int      iVertSpacing;
2869   int      iTitleWrap;
2870   LOGFONTA lfFont;
2871 } ICONMETRICSA, *LPICONMETRICSA;
2872
2873 typedef struct tagICONMETRICSW {
2874   UINT     cbSize;
2875   int      iHorzSpacing;
2876   int      iVertSpacing;
2877   int      iTitleWrap;
2878   LOGFONTW lfFont;
2879 } ICONMETRICSW, *LPICONMETRICSW;
2880
2881 typedef_tident(ICONMETRICS)
2882 typedef_tident(LPICONMETRICS)
2883
2884 typedef struct _IMAGEINFO {
2885   HBITMAP hbmImage;
2886   HBITMAP hbmMask;
2887   int     Unused1;
2888   int     Unused2;
2889   RECT    rcImage;
2890 } IMAGEINFO;
2891
2892 typedef struct _JOB_INFO_1A {
2893   DWORD  JobId;
2894   LPSTR  pPrinterName;
2895   LPSTR  pMachineName;
2896   LPSTR  pUserName;
2897   LPSTR  pDocument;
2898   LPSTR  pDatatype;
2899   LPSTR  pStatus;
2900   DWORD  Status;
2901   DWORD  Priority;
2902   DWORD  Position;
2903   DWORD  TotalPages;
2904   DWORD  PagesPrinted;
2905   SYSTEMTIME Submitted;
2906 } JOB_INFO_1A;
2907
2908 typedef struct _JOB_INFO_1W {
2909   DWORD  JobId;
2910   LPWSTR pPrinterName;
2911   LPWSTR pMachineName;
2912   LPWSTR pUserName;
2913   LPWSTR pDocument;
2914   LPWSTR pDatatype;
2915   LPWSTR pStatus;
2916   DWORD  Status;
2917   DWORD  Priority;
2918   DWORD  Position;
2919   DWORD  TotalPages;
2920   DWORD  PagesPrinted;
2921   SYSTEMTIME Submitted;
2922 } JOB_INFO_1W;
2923
2924 typedef_tident(JOB_INFO_1)
2925
2926 #if 0
2927 typedef struct _JOB_INFO_2A {
2928   DWORD      JobId;
2929   LPSTR      pPrinterName;
2930   LPSTR      pMachineName;
2931   LPSTR      pUserName;
2932   LPSTR      pDocument;
2933   LPSTR      pNotifyName;
2934   LPSTR      pDatatype;
2935   LPSTR      pPrintProcessor;
2936   LPSTR      pParameters;
2937   LPSTR      pDriverName;
2938   LPDEVMODE  pDevMode;
2939   LPSTR      pStatus;
2940   PSECURITY_DESCRIPTOR pSecurityDescriptor;
2941   DWORD      Status;
2942   DWORD      Priority;
2943   DWORD      Position;
2944   DWORD      StartTime;
2945   DWORD      UntilTime;
2946   DWORD      TotalPages;
2947   DWORD      Size;
2948   SYSTEMTIME Submitted;
2949   DWORD      Time;
2950   DWORD      PagesPrinted ;
2951 } JOB_INFO_2A;
2952
2953 typedef struct _JOB_INFO_2W {
2954   DWORD      JobId;
2955   LPWSTR     pPrinterName;
2956   LPWSTR     pMachineName;
2957   LPWSTR     pUserName;
2958   LPWSTR     pDocument;
2959   LPWSTR     pNotifyName;
2960   LPWSTR     pDatatype;
2961   LPWSTR     pPrintProcessor;
2962   LPWSTR     pParameters;
2963   LPWSTR     pDriverName;
2964   LPDEVMODE  pDevMode;
2965   LPWSTR     pStatus;
2966   PSECURITY_DESCRIPTOR pSecurityDescriptor;
2967   DWORD      Status;
2968   DWORD      Priority;
2969   DWORD      Position;
2970   DWORD      StartTime;
2971   DWORD      UntilTime;
2972   DWORD      TotalPages;
2973   DWORD      Size;
2974   SYSTEMTIME Submitted;
2975   DWORD      Time;
2976   DWORD      PagesPrinted ;
2977 } JOB_INFO_2W;
2978
2979 typedef_tident(JOB_INFO_2)
2980 #endif/*0*/
2981
2982 typedef struct tagKERNINGPAIR {
2983   WORD wFirst;
2984   WORD wSecond;
2985   int  iKernAmount;
2986 } KERNINGPAIR, *LPKERNINGPAIR;
2987
2988 typedef struct _LANA_ENUM {
2989   UCHAR length;
2990   UCHAR lana[MAX_LANA];
2991 } LANA_ENUM;
2992
2993
2994 typedef struct tagLOADPARMS32 {
2995   LPSTR lpEnvAddress;
2996   LPSTR lpCmdLine;
2997   LPSTR lpCmdShow;
2998   DWORD dwReserved;
2999 } LOADPARMS32;
3000
3001
3002 typedef struct tagLOCALESIGNATURE {
3003   DWORD  lsUsb[4];
3004   DWORD  lsCsbDefault[2];
3005   DWORD  lsCsbSupported[2];
3006 } LOCALESIGNATURE;
3007
3008    #if 0
3009 typedef struct _LOCALGROUP_MEMBERS_INFO_0 {
3010   PSID  lgrmi0_sid;
3011 } LOCALGROUP_MEMBERS_INFO_0;
3012  #endif
3013
3014 typedef struct _LOCALGROUP_MEMBERS_INFO_3 {
3015   LPWSTR  lgrmi3_domainandname;
3016 } LOCALGROUP_MEMBERS_INFO_3;
3017
3018 typedef long FXPT16DOT16,  * LPFXPT16DOT16;
3019
3020
3021
3022 typedef LUID_AND_ATTRIBUTES LUID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY];
3023 typedef LUID_AND_ATTRIBUTES_ARRAY *PLUID_AND_ATTRIBUTES_ARRAY;
3024
3025 typedef struct _LV_COLUMNA {
3026   UINT mask;
3027   int fmt;
3028   int cx;
3029   LPSTR pszText;
3030   int cchTextMax;
3031   int iSubItem;
3032 } LV_COLUMNA;
3033
3034 typedef struct _LV_COLUMNW {
3035   UINT mask;
3036   int fmt;
3037   int cx;
3038   LPWSTR pszText;
3039   int cchTextMax;
3040   int iSubItem;
3041 } LV_COLUMNW;
3042
3043 typedef_tident(LV_COLUMN)
3044
3045 typedef struct _LV_ITEMA {
3046   UINT   mask;
3047   int    iItem;
3048   int    iSubItem;
3049   UINT   state;
3050   UINT   stateMask;
3051   LPSTR  pszText;
3052   int    cchTextMax;
3053   int    iImage;
3054   LPARAM lParam;
3055 } LV_ITEMA;
3056
3057 typedef struct _LV_ITEMW {
3058   UINT   mask;
3059   int    iItem;
3060   int    iSubItem;
3061   UINT   state;
3062   UINT   stateMask;
3063   LPWSTR  pszText;
3064   int    cchTextMax;
3065   int    iImage;
3066   LPARAM lParam;
3067 } LV_ITEMW;
3068
3069 typedef_tident(LV_ITEM)
3070
3071 typedef struct tagLV_DISPINFOA {
3072   NMHDR    hdr;
3073   LV_ITEMA item;
3074 } LV_DISPINFOA;
3075
3076 typedef struct tagLV_DISPINFOW {
3077   NMHDR    hdr;
3078   LV_ITEMW item;
3079 } LV_DISPINFOW;
3080
3081 typedef_tident(LV_DISPINFO)
3082
3083 typedef struct _LV_FINDINFOA {
3084   UINT flags;
3085   LPCSTR psz;
3086   LPARAM lParam;
3087   POINT pt;
3088   UINT vkDirection;
3089 } LV_FINDINFOA;
3090
3091 typedef struct _LV_FINDINFOW {
3092   UINT flags;
3093   LPCWSTR psz;
3094   LPARAM lParam;
3095   POINT pt;
3096   UINT vkDirection;
3097 } LV_FINDINFOW;
3098
3099 typedef_tident(LV_FINDINFO)
3100
3101 typedef struct _LV_HITTESTINFO {
3102   POINT pt;
3103   UINT flags;
3104   int iItem;
3105 } LV_HITTESTINFO;
3106
3107 typedef struct tagLV_KEYDOWN {
3108   NMHDR hdr;
3109   WORD wVKey;
3110   UINT flags;
3111 } LV_KEYDOWN;
3112
3113 typedef struct _MAT2 {
3114   FIXED eM11;
3115   FIXED eM12;
3116   FIXED eM21;
3117   FIXED eM22;
3118 } MAT2, *LPMAT2;
3119
3120 typedef struct tagMDICREATESTRUCTA {
3121   LPCSTR  szClass;
3122   LPCSTR  szTitle;
3123   HANDLE  hOwner;
3124   int     x;
3125   int     y;
3126   int     cx;
3127   int     cy;
3128   DWORD   style;
3129   LPARAM  lParam;
3130 } MDICREATESTRUCTA, *LPMDICREATESTRUCTA;
3131
3132 typedef struct tagMDICREATESTRUCTW {
3133   LPCWSTR szClass;
3134   LPCWSTR szTitle;
3135   HANDLE  hOwner;
3136   int     x;
3137   int     y;
3138   int     cx;
3139   int     cy;
3140   DWORD   style;
3141   LPARAM  lParam;
3142 } MDICREATESTRUCTW, *LPMDICREATESTRUCTW;
3143
3144 typedef_tident(MDICREATESTRUCT)
3145 typedef_tident(LPMDICREATESTRUCT)
3146
3147 typedef struct tagMDINEXTMENU {
3148         HMENU hmenuIn;
3149         HMENU hmenuNext;
3150         HWND hwndNext;
3151 } MDINEXTMENU,*PMDINEXTMENU,*LPMDINEXTMENU;
3152
3153 typedef struct tagMEASUREITEMSTRUCT {
3154   UINT  CtlType;
3155   UINT  CtlID;
3156   UINT  itemID;
3157   UINT  itemWidth;
3158   UINT  itemHeight;
3159   DWORD itemData;
3160 } MEASUREITEMSTRUCT, *LPMEASUREITEMSTRUCT;
3161
3162 typedef struct _MEMORYSTATUS {
3163   DWORD dwLength;
3164   DWORD dwMemoryLoad;
3165   DWORD dwTotalPhys;
3166   DWORD dwAvailPhys;
3167   DWORD dwTotalPageFile;
3168   DWORD dwAvailPageFile;
3169   DWORD dwTotalVirtual;
3170   DWORD dwAvailVirtual;
3171 } MEMORYSTATUS, *LPMEMORYSTATUS;
3172
3173 typedef struct {
3174   WORD  wVersion;
3175   WORD  wOffset;
3176   DWORD dwHelpId;
3177 } MENUEX_TEMPLATE_HEADER;
3178
3179 typedef struct {
3180   DWORD  dwType;
3181   DWORD  dwState;
3182   UINT   uId;
3183   BYTE   bResInfo;
3184   WCHAR  szText[1];
3185   DWORD dwHelpId;
3186 } MENUEX_TEMPLATE_ITEM;
3187
3188
3189 typedef struct tagMENUITEMINFOA {
3190   UINT    cbSize;
3191   UINT    fMask;
3192   UINT    fType;
3193   UINT    fState;
3194   UINT    wID;
3195   HMENU   hSubMenu;
3196   HBITMAP hbmpChecked;
3197   HBITMAP hbmpUnchecked;
3198   DWORD   dwItemData;
3199   LPSTR   dwTypeData;
3200   UINT    cch;
3201   HBITMAP  hbmpItem;
3202 } MENUITEMINFOA, *LPMENUITEMINFOA;
3203 typedef CONST MENUITEMINFOA* LPCMENUITEMINFOA;
3204
3205 typedef struct tagMENUITEMINFOW {
3206   UINT    cbSize;
3207   UINT    fMask;
3208   UINT    fType;
3209   UINT    fState;
3210   UINT    wID;
3211   HMENU   hSubMenu;
3212   HBITMAP hbmpChecked;
3213   HBITMAP hbmpUnchecked;
3214   DWORD   dwItemData;
3215   LPWSTR  dwTypeData;
3216   UINT    cch;
3217   HBITMAP  hbmpItem;
3218 } MENUITEMINFOW, *LPMENUITEMINFOW;
3219 typedef CONST MENUITEMINFOW* LPCMENUITEMINFOW;
3220
3221 typedef_tident(MENUITEMINFO)
3222 typedef_tident(LPMENUITEMINFO)
3223 typedef_tident(LPCMENUITEMINFO)
3224
3225 typedef struct {
3226   WORD mtOption;
3227   WORD mtID;
3228   WCHAR mtString[1];
3229 } MENUITEMTEMPLATE;
3230
3231 typedef struct {
3232   WORD versionNumber;
3233   WORD offset;
3234 } MENUITEMTEMPLATEHEADER;
3235 typedef VOID MENUTEMPLATE, *LPMENUTEMPLATE;
3236
3237 typedef struct tagMETAFILEPICT {
3238   LONG      mm;
3239   LONG      xExt;
3240   LONG      yExt;
3241   HMETAFILE hMF;
3242 } METAFILEPICT, *PMETAFILEPICT, *LPMETAFILEPICT;
3243
3244
3245 #include <pshpack1.h>
3246
3247 typedef struct tagMETAHEADER {
3248   WORD  mtType;
3249   WORD  mtHeaderSize;
3250   WORD  mtVersion;
3251   DWORD mtSize;
3252   WORD  mtNoObjects;
3253   DWORD mtMaxRecord;
3254   WORD  mtNoParameters;
3255 } METAHEADER;
3256
3257 #include <poppack.h>
3258
3259
3260 typedef struct tagMETARECORD {
3261   DWORD rdSize;
3262   WORD  rdFunction;
3263   WORD  rdParm[1];
3264 } METARECORD, *LPMETARECORD;
3265
3266 typedef struct tagMINIMIZEDMETRICS {
3267   UINT    cbSize;
3268   int     iWidth;
3269   int     iHorzGap;
3270   int     iVertGap;
3271   int     iArrange;
3272 }   MINIMIZEDMETRICS,   *LPMINIMIZEDMETRICS;
3273
3274 typedef struct tagMINMAXINFO {
3275   POINT ptReserved;
3276   POINT ptMaxSize;
3277   POINT ptMaxPosition;
3278   POINT ptMinTrackSize;
3279   POINT ptMaxTrackSize;
3280 } MINMAXINFO;
3281
3282 typedef struct modemdevcaps_tag {
3283   DWORD dwActualSize;
3284   DWORD dwRequiredSize;
3285   DWORD dwDevSpecificOffset;
3286   DWORD dwDevSpecificSize;
3287
3288   DWORD dwModemProviderVersion;
3289   DWORD dwModemManufacturerOffset;
3290   DWORD dwModemManufacturerSize;
3291   DWORD dwModemModelOffset;
3292   DWORD dwModemModelSize;
3293   DWORD dwModemVersionOffset;
3294   DWORD dwModemVersionSize;
3295
3296   DWORD dwDialOptions;
3297   DWORD dwCallSetupFailTimer;
3298   DWORD dwInactivityTimeout;
3299   DWORD dwSpeakerVolume;
3300   DWORD dwSpeakerMode;
3301   DWORD dwModemOptions;
3302   DWORD dwMaxDTERate;
3303   DWORD dwMaxDCERate;
3304
3305   BYTE abVariablePortion [1];
3306 } MODEMDEVCAPS, *PMODEMDEVCAPS, *LPMODEMDEVCAPS;
3307
3308 typedef struct modemsettings_tag {
3309   DWORD dwActualSize;
3310   DWORD dwRequiredSize;
3311   DWORD dwDevSpecificOffset;
3312   DWORD dwDevSpecificSize;
3313
3314   DWORD dwCallSetupFailTimer;
3315   DWORD dwInactivityTimeout;
3316   DWORD dwSpeakerVolume;
3317   DWORD dwSpeakerMode;
3318   DWORD dwPreferredModemOptions;
3319
3320   DWORD dwNegotiatedModemOptions;
3321   DWORD dwNegotiatedDCERate;
3322
3323   BYTE  abVariablePortion[1];
3324 } MODEMSETTINGS, *PMODEMSETTINGS, *LPMODEMSETTINGS;
3325
3326 typedef struct tagMONCBSTRUCT {
3327   UINT   cb;
3328   DWORD  dwTime;
3329   HANDLE hTask;
3330   DWORD  dwRet;
3331   UINT   wType;
3332   UINT   wFmt;
3333   HCONV  hConv;
3334   HSZ    hsz1;
3335   HSZ    hsz2;
3336   HDDEDATA hData;
3337   DWORD    dwData1;
3338   DWORD    dwData2;
3339   CONVCONTEXT cc;
3340   DWORD  cbData;
3341   DWORD  Data[8];
3342 } MONCBSTRUCT;
3343
3344 typedef struct tagMONCONVSTRUCT {
3345   UINT   cb;
3346   WINBOOL   fConnect;
3347   DWORD  dwTime;
3348   HANDLE hTask;
3349   HSZ    hszSvc;
3350   HSZ    hszTopic;
3351   HCONV  hConvClient;
3352   HCONV  hConvServer;
3353 } MONCONVSTRUCT;
3354
3355 typedef struct tagMONERRSTRUCT {
3356   UINT   cb;
3357   UINT   wLastError;
3358   DWORD  dwTime;
3359   HANDLE hTask;
3360 } MONERRSTRUCT;
3361
3362 typedef struct tagMONHSZSTRUCTA {
3363   UINT   cb;
3364   WINBOOL   fsAction;
3365   DWORD  dwTime;
3366   HSZ    hsz;
3367   HANDLE hTask;
3368   CHAR   str[1];
3369 } MONHSZSTRUCTA;
3370
3371 typedef struct tagMONHSZSTRUCTW {
3372   UINT   cb;
3373   WINBOOL   fsAction;
3374   DWORD  dwTime;
3375   HSZ    hsz;
3376   HANDLE hTask;
3377   WCHAR   str[1];
3378 } MONHSZSTRUCTW;
3379
3380 typedef_tident(MONHSZSTRUCT)
3381
3382 typedef struct _MONITOR_INFO_1A {
3383   LPSTR  pName;
3384 } MONITOR_INFO_1A;
3385
3386 typedef struct _MONITOR_INFO_1W {
3387   LPWSTR pName;
3388 } MONITOR_INFO_1W;
3389
3390 typedef_tident(MONITOR_INFO_1)
3391
3392 typedef struct _MONITOR_INFO_2A {
3393   LPSTR  pName;
3394   LPSTR  pEnvironment ;
3395   LPSTR  pDLLName ;
3396 } MONITOR_INFO_2A;
3397
3398 typedef struct _MONITOR_INFO_2W {
3399   LPWSTR pName;
3400   LPWSTR pEnvironment ;
3401   LPWSTR pDLLName ;
3402 } MONITOR_INFO_2W;
3403
3404 typedef_tident(MONITOR_INFO_2)
3405
3406 typedef struct tagMONLINKSTRUCT {
3407   UINT   cb;
3408   DWORD  dwTime;
3409   HANDLE hTask;
3410   WINBOOL   fEstablished;
3411   WINBOOL   fNoData;
3412   HSZ    hszSvc;
3413   HSZ    hszTopic;
3414   HSZ    hszItem;
3415   UINT   wFmt;
3416   WINBOOL   fServer;
3417   HCONV  hConvServer;
3418   HCONV  hConvClient;
3419 } MONLINKSTRUCT;
3420
3421 typedef struct tagMONMSGSTRUCT {
3422   UINT   cb;
3423   HWND   hwndTo;
3424   DWORD  dwTime;
3425   HANDLE hTask;
3426   UINT   wMsg;
3427   WPARAM wParam;
3428   LPARAM lParam;
3429   DDEML_MSG_HOOK_DATA dmhd;
3430 } MONMSGSTRUCT;
3431
3432 typedef struct tagMOUSEHOOKSTRUCT {
3433   POINT pt;
3434   HWND  hwnd;
3435   UINT  wHitTestCode;
3436   DWORD dwExtraInfo;
3437 } MOUSEHOOKSTRUCT, *PMOUSEHOOKSTRUCT, *LPMOUSEHOOKSTRUCT;
3438
3439 typedef struct _MOUSEKEYS {
3440   DWORD cbSize;
3441   DWORD dwFlags;
3442   DWORD iMaxSpeed;
3443   DWORD iTimeToMaxSpeed;
3444   DWORD iCtrlSpeed;
3445   DWORD dwReserved1;
3446   DWORD dwReserved2;
3447 } MOUSEKEYS;
3448
3449 typedef struct tagMSG {
3450   HWND   hwnd;
3451   UINT   message;
3452   WPARAM wParam;
3453   LPARAM lParam;
3454   DWORD  time;
3455   POINT  pt;
3456 } MSG, *LPMSG;
3457
3458 typedef void (CALLBACK *MSGBOXCALLBACK) (LPHELPINFO lpHelpInfo);
3459
3460 typedef struct {
3461   UINT      cbSize;
3462   HWND      hwndOwner;
3463   HINSTANCE hInstance;
3464   LPCSTR    lpszText;
3465   LPCSTR    lpszCaption;
3466   DWORD     dwStyle;
3467   LPCSTR    lpszIcon;
3468   DWORD     dwContextHelpId;
3469   MSGBOXCALLBACK lpfnMsgBoxCallback;
3470   DWORD     dwLanguageId;
3471 } MSGBOXPARAMS, *PMSGBOXPARAMS,   *LPMSGBOXPARAMS;
3472
3473 typedef struct _msgfilter {
3474   NMHDR nmhdr;
3475   UINT msg;
3476   WPARAM wParam;
3477   LPARAM lParam;
3478 } MSGFILTER;
3479
3480 typedef struct _NAME_BUFFER {
3481   UCHAR name[NCBNAMSZ];
3482   UCHAR name_num;
3483   UCHAR name_flags;
3484 } NAME_BUFFER;
3485
3486 typedef struct _NCB {
3487   UCHAR  ncb_command;
3488   UCHAR  ncb_retcode;
3489   UCHAR  ncb_lsn;
3490   UCHAR  ncb_num;
3491   PUCHAR ncb_buffer;
3492   WORD   ncb_length;
3493   UCHAR  ncb_callname[NCBNAMSZ];
3494   UCHAR  ncb_name[NCBNAMSZ];
3495   UCHAR  ncb_rto;
3496   UCHAR  ncb_sto;
3497   void (*ncb_post) (struct _NCB *);
3498   UCHAR  ncb_lana_num;
3499   UCHAR  ncb_cmd_cplt;
3500   UCHAR  ncb_reserve[10];
3501   HANDLE ncb_event;
3502 } NCB;
3503
3504 typedef struct _NCCALCSIZE_PARAMS {
3505   RECT        rgrc[3];
3506   PWINDOWPOS  lppos;
3507 } NCCALCSIZE_PARAMS;
3508
3509 typedef struct _NDDESHAREINFOA {
3510   LONG   lRevision;
3511   LPSTR  lpszShareName;
3512   LONG   lShareType;
3513   LPSTR  lpszAppTopicList;
3514   LONG   fSharedFlag;
3515   LONG   fService;
3516   LONG   fStartAppFlag;
3517   LONG   nCmdShow;
3518   LONG   qModifyId[2];
3519   LONG   cNumItems;
3520   LPSTR  lpszItemList;
3521 }NDDESHAREINFOA;
3522
3523 typedef struct _NDDESHAREINFOW {
3524   LONG   lRevision;
3525   LPWSTR lpszShareName;
3526   LONG   lShareType;
3527   LPWSTR lpszAppTopicList;
3528   LONG   fSharedFlag;
3529   LONG   fService;
3530   LONG   fStartAppFlag;
3531   LONG   nCmdShow;
3532   LONG   qModifyId[2];
3533   LONG   cNumItems;
3534   LPWSTR lpszItemList;
3535 }NDDESHAREINFOW;
3536
3537 typedef_tident(NDDESHAREINFO)
3538
3539 typedef struct _NETRESOURCEA {
3540   DWORD  dwScope;
3541   DWORD  dwType;
3542   DWORD  dwDisplayType;
3543   DWORD  dwUsage;
3544   LPSTR  lpLocalName;
3545   LPSTR  lpRemoteName;
3546   LPSTR  lpComment;
3547   LPSTR  lpProvider;
3548 } NETRESOURCEA, *LPNETRESOURCEA;
3549
3550 typedef struct _NETRESOURCEW {
3551   DWORD  dwScope;
3552   DWORD  dwType;
3553   DWORD  dwDisplayType;
3554   DWORD  dwUsage;
3555   LPWSTR lpLocalName;
3556   LPWSTR lpRemoteName;
3557   LPWSTR lpComment;
3558   LPWSTR lpProvider;
3559 } NETRESOURCEW, *LPNETRESOURCEW;
3560
3561 typedef_tident(NETRESOURCE)
3562 typedef_tident(LPNETRESOURCE)
3563
3564 typedef struct tagNEWCPLINFOA {
3565   DWORD dwSize;
3566   DWORD dwFlags;
3567   DWORD dwHelpContext;
3568   LONG  lData;
3569   HICON hIcon;
3570   CHAR  szName[32];
3571   CHAR  szInfo[64];
3572   CHAR  szHelpFile[128];
3573 } NEWCPLINFOA;
3574
3575 typedef struct tagNEWCPLINFOW {
3576   DWORD dwSize;
3577   DWORD dwFlags;
3578   DWORD dwHelpContext;
3579   LONG  lData;
3580   HICON hIcon;
3581   WCHAR  szName[32];
3582   WCHAR  szInfo[64];
3583   WCHAR  szHelpFile[128];
3584 } NEWCPLINFOW;
3585
3586 typedef_tident(NEWCPLINFO)
3587
3588 typedef struct tagNEWTEXTMETRICA {
3589   LONG   tmHeight;
3590   LONG   tmAscent;
3591   LONG   tmDescent;
3592   LONG   tmInternalLeading;
3593   LONG   tmExternalLeading;
3594   LONG   tmAveCharWidth;
3595   LONG   tmMaxCharWidth;
3596   LONG   tmWeight;
3597   LONG   tmOverhang;
3598   LONG   tmDigitizedAspectX;
3599   LONG   tmDigitizedAspectY;
3600   CHAR   tmFirstChar;
3601   CHAR   tmLastChar;
3602   CHAR   tmDefaultChar;
3603   CHAR   tmBreakChar;
3604   BYTE   tmItalic;
3605   BYTE   tmUnderlined;
3606   BYTE   tmStruckOut;
3607   BYTE   tmPitchAndFamily;
3608   BYTE   tmCharSet;
3609   DWORD  ntmFlags;
3610   UINT   ntmSizeEM;
3611   UINT   ntmCellHeight;
3612   UINT   ntmAvgWidth;
3613 } NEWTEXTMETRICA;
3614
3615 typedef struct tagNEWTEXTMETRICW {
3616   LONG   tmHeight;
3617   LONG   tmAscent;
3618   LONG   tmDescent;
3619   LONG   tmInternalLeading;
3620   LONG   tmExternalLeading;
3621   LONG   tmAveCharWidth;
3622   LONG   tmMaxCharWidth;
3623   LONG   tmWeight;
3624   LONG   tmOverhang;
3625   LONG   tmDigitizedAspectX;
3626   LONG   tmDigitizedAspectY;
3627   WCHAR  tmFirstChar;
3628   WCHAR  tmLastChar;
3629   WCHAR  tmDefaultChar;
3630   WCHAR  tmBreakChar;
3631   BYTE   tmItalic;
3632   BYTE   tmUnderlined;
3633   BYTE   tmStruckOut;
3634   BYTE   tmPitchAndFamily;
3635   BYTE   tmCharSet;
3636   DWORD  ntmFlags;
3637   UINT   ntmSizeEM;
3638   UINT   ntmCellHeight;
3639   UINT   ntmAvgWidth;
3640 } NEWTEXTMETRICW;
3641
3642 typedef_tident(NEWTEXTMETRIC)
3643
3644 typedef struct tagNEWTEXTMETRICEXA {
3645   NEWTEXTMETRICA ntmTm;
3646   FONTSIGNATURE  ntmFontSig;
3647 } NEWTEXTMETRICEXA;
3648
3649 typedef struct tagNEWTEXTMETRICEXW {
3650   NEWTEXTMETRICW ntmTm;
3651   FONTSIGNATURE  ntmFontSig;
3652 } NEWTEXTMETRICEXW;
3653
3654 typedef_tident(NEWTEXTMETRICEX)
3655
3656 typedef struct tagNM_LISTVIEW {
3657   NMHDR hdr;
3658   int   iItem;
3659   int   iSubItem;
3660   UINT  uNewState;
3661   UINT  uOldState;
3662   UINT  uChanged;
3663   POINT ptAction;
3664   LPARAM lParam;
3665 } NM_LISTVIEW;
3666
3667 typedef struct _TREEITEM *HTREEITEM;
3668
3669 typedef struct _TV_ITEMA {
3670   UINT       mask;
3671   HTREEITEM  hItem;
3672   UINT       state;
3673   UINT       stateMask;
3674   LPSTR      pszText;
3675   int        cchTextMax;
3676   int        iImage;
3677   int        iSelectedImage;
3678   int        cChildren;
3679   LPARAM     lParam;
3680 } TV_ITEMA,   *LPTV_ITEMA;
3681
3682 typedef struct _TV_ITEMW {
3683   UINT       mask;
3684   HTREEITEM  hItem;
3685   UINT       state;
3686   UINT       stateMask;
3687   LPWSTR     pszText;
3688   int        cchTextMax;
3689   int        iImage;
3690   int        iSelectedImage;
3691   int        cChildren;
3692   LPARAM     lParam;
3693 } TV_ITEMW,   *LPTV_ITEMW;
3694
3695 typedef_tident(TV_ITEM)
3696 typedef_tident(LPTV_ITEM)
3697
3698 typedef struct _NM_TREEVIEWA {
3699   NMHDR    hdr;
3700   UINT     action;
3701   TV_ITEMA itemOld;
3702   TV_ITEMA itemNew;
3703   POINT    ptDrag;
3704 } NM_TREEVIEWA, *LPNM_TREEVIEWA;
3705
3706 typedef struct _NM_TREEVIEWW {
3707   NMHDR    hdr;
3708   UINT     action;
3709   TV_ITEMW itemOld;
3710   TV_ITEMW itemNew;
3711   POINT    ptDrag;
3712 } NM_TREEVIEWW, *LPNM_TREEVIEWW;
3713
3714 typedef_tident(NM_TREEVIEW)
3715 typedef_tident(LPNM_TREEVIEW)
3716
3717
3718 typedef struct _NM_UPDOWN {
3719   NMHDR    hdr;
3720   int     iPos;
3721   int  iDelta;
3722 } NM_UPDOWNW;
3723
3724 typedef struct tagNONCLIENTMETRICSA {
3725   UINT     cbSize;
3726   int      iBorderWidth;
3727   int      iScrollWidth;
3728   int      iScrollHeight;
3729   int      iCaptionWidth;
3730   int      iCaptionHeight;
3731   LOGFONTA lfCaptionFont;
3732   int      iSmCaptionWidth;
3733   int      iSmCaptionHeight;
3734   LOGFONTA lfSmCaptionFont;
3735   int      iMenuWidth;
3736   int      iMenuHeight;
3737   LOGFONTA lfMenuFont;
3738   LOGFONTA lfStatusFont;
3739   LOGFONTA lfMessageFont;
3740 } NONCLIENTMETRICSA, *LPNONCLIENTMETRICSA;
3741
3742 typedef struct tagNONCLIENTMETRICSW {
3743   UINT     cbSize;
3744   int      iBorderWidth;
3745   int      iScrollWidth;
3746   int      iScrollHeight;
3747   int      iCaptionWidth;
3748   int      iCaptionHeight;
3749   LOGFONTW lfCaptionFont;
3750   int      iSmCaptionWidth;
3751   int      iSmCaptionHeight;
3752   LOGFONTW lfSmCaptionFont;
3753   int      iMenuWidth;
3754   int      iMenuHeight;
3755   LOGFONTW lfMenuFont;
3756   LOGFONTW lfStatusFont;
3757   LOGFONTW lfMessageFont;
3758 } NONCLIENTMETRICSW, *LPNONCLIENTMETRICSW;
3759
3760 typedef_tident(NONCLIENTMETRICS)
3761 typedef_tident(LPNONCLIENTMETRICS)
3762
3763 #include <serviceinfo.h>
3764
3765 #ifndef GUID_DEFINED
3766 #define GUID_DEFINED
3767
3768 typedef struct _GUID
3769 {
3770     unsigned long  Data1;
3771     unsigned short  Data2;
3772     unsigned short  Data3;
3773     unsigned char Data4[8];
3774 } GUID, *LPGUID;
3775 typedef GUID CLSID, *LPCLSID;
3776
3777 #endif/*GUID_DEFINED*/
3778
3779 typedef_tident(SERVICE_INFO);
3780 typedef_tident(LPSERVICE_INFO);
3781
3782 typedef struct _NS_SERVICE_INFOA {
3783   DWORD         dwNameSpace;
3784   SERVICE_INFOA ServiceInfo;
3785 } NS_SERVICE_INFOA;
3786
3787 typedef struct _NS_SERVICE_INFOW {
3788   DWORD         dwNameSpace;
3789   SERVICE_INFOW ServiceInfo;
3790 } NS_SERVICE_INFOW;
3791
3792 typedef_tident(NS_SERVICE_INFO);
3793
3794 typedef struct _numberfmtA {
3795   UINT      NumDigits;
3796   UINT      LeadingZero;
3797   UINT      Grouping;
3798   LPSTR     lpDecimalSep;
3799   LPSTR     lpThousandSep;
3800   UINT      NegativeOrder;
3801 } NUMBERFMTA;
3802
3803 typedef struct _numberfmtW {
3804   UINT      NumDigits;
3805   UINT      LeadingZero;
3806   UINT      Grouping;
3807   LPWSTR    lpDecimalSep;
3808   LPWSTR    lpThousandSep;
3809   UINT      NegativeOrder;
3810 } NUMBERFMTW;
3811
3812 typedef_tident(NUMBERFMT)
3813
3814 typedef struct _OFSTRUCT {
3815   BYTE cBytes;
3816   BYTE fFixedDisk;
3817   WORD nErrCode;
3818   WORD Reserved1;
3819   WORD Reserved2;
3820   CHAR szPathName[OFS_MAXPATHNAME];
3821 } OFSTRUCT, *LPOFSTRUCT;
3822
3823 typedef struct tagOFNA {
3824   DWORD         lStructSize;
3825   HWND          hwndOwner;
3826   HINSTANCE     hInstance;
3827   LPCSTR        lpstrFilter;
3828   LPSTR         lpstrCustomFilter;
3829   DWORD         nMaxCustFilter;
3830   DWORD         nFilterIndex;
3831   LPSTR         lpstrFile;
3832   DWORD         nMaxFile;
3833   LPSTR         lpstrFileTitle;
3834   DWORD         nMaxFileTitle;
3835   LPCSTR        lpstrInitialDir;
3836   LPCSTR        lpstrTitle;
3837   DWORD         Flags;
3838   WORD          nFileOffset;
3839   WORD          nFileExtension;
3840   LPCSTR        lpstrDefExt;
3841   DWORD         lCustData;
3842   LPOFNHOOKPROC lpfnHook;
3843   LPCSTR        lpTemplateName;
3844 } OPENFILENAMEA, *LPOPENFILENAMEA;
3845
3846 typedef struct tagOFNW {
3847   DWORD         lStructSize;
3848   HWND          hwndOwner;
3849   HINSTANCE     hInstance;
3850   LPCWSTR       lpstrFilter;
3851   LPWSTR        lpstrCustomFilter;
3852   DWORD         nMaxCustFilter;
3853   DWORD         nFilterIndex;
3854   LPWSTR        lpstrFile;
3855   DWORD         nMaxFile;
3856   LPWSTR        lpstrFileTitle;
3857   DWORD         nMaxFileTitle;
3858   LPCWSTR       lpstrInitialDir;
3859   LPCWSTR       lpstrTitle;
3860   DWORD         Flags;
3861   WORD          nFileOffset;
3862   WORD          nFileExtension;
3863   LPCWSTR       lpstrDefExt;
3864   DWORD         lCustData;
3865   LPOFNHOOKPROC lpfnHook;
3866   LPCWSTR       lpTemplateName;
3867 } OPENFILENAMEW, *LPOPENFILENAMEW;
3868
3869 typedef_tident(OPENFILENAME)
3870 typedef_tident(LPOPENFILENAME)
3871
3872 typedef struct _OFNOTIFYA {
3873   NMHDR           hdr;
3874   LPOPENFILENAMEA lpOFN;
3875   LPSTR           pszFile;
3876 } OFNOTIFYA, *LPOFNOTIFYA;
3877
3878 typedef struct _OFNOTIFYW {
3879   NMHDR           hdr;
3880   LPOPENFILENAMEW lpOFN;
3881   LPWSTR          pszFile;
3882 } OFNOTIFYW, *LPOFNOTIFYW;
3883
3884 typedef_tident(OFNOTIFY)
3885 typedef_tident(LPOFNOTIFY)
3886
3887 typedef struct _OSVERSIONINFOA {
3888   DWORD dwOSVersionInfoSize;
3889   DWORD dwMajorVersion;
3890   DWORD dwMinorVersion;
3891   DWORD dwBuildNumber;
3892   DWORD dwPlatformId;
3893   CHAR szCSDVersion[ 128 ];
3894 } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
3895
3896 typedef struct _OSVERSIONINFOW {
3897   DWORD dwOSVersionInfoSize;
3898   DWORD dwMajorVersion;
3899   DWORD dwMinorVersion;
3900   DWORD dwBuildNumber;
3901   DWORD dwPlatformId;
3902   WCHAR szCSDVersion[ 128 ];
3903 } OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
3904
3905 typedef_tident(OSVERSIONINFO)
3906
3907 typedef struct _OSVERSIONINFOEXA
3908 #if defined(__cplusplus)
3909 : public OSVERSIONINFOA
3910 {
3911 #elif 0
3912 {
3913  OSVERSIONINFOA;
3914 #else
3915 {
3916  DWORD dwOSVersionInfoSize;
3917  DWORD dwMajorVersion;
3918  DWORD dwMinorVersion;
3919  DWORD dwBuildNumber;
3920  DWORD dwPlatformId;
3921  CHAR szCSDVersion[ 128 ];
3922 #endif
3923  WORD wServicePackMajor;
3924  WORD wServicePackMinor;
3925  WORD wSuiteMask;
3926  BYTE wProductType;
3927  BYTE wReserved;
3928 } OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA;
3929
3930 typedef struct _OSVERSIONINFOEXW
3931 #if defined(__cplusplus)
3932 : public OSVERSIONINFOW
3933 {
3934 #elif 0
3935 {
3936  OSVERSIONINFOW;
3937 #else
3938 {
3939  DWORD dwOSVersionInfoSize;
3940  DWORD dwMajorVersion;
3941  DWORD dwMinorVersion;
3942  DWORD dwBuildNumber;
3943  DWORD dwPlatformId;
3944  WCHAR szCSDVersion[ 128 ];
3945 #endif
3946  WORD wServicePackMajor;
3947  WORD wServicePackMinor;
3948  WORD wSuiteMask;
3949  BYTE wProductType;
3950  BYTE wReserved;
3951 } OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW, RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW;
3952
3953 typedef_tident(OSVERSIONINFOEX)
3954
3955 typedef struct tagTEXTMETRICA {
3956   LONG tmHeight;
3957   LONG tmAscent;
3958   LONG tmDescent;
3959   LONG tmInternalLeading;
3960   LONG tmExternalLeading;
3961   LONG tmAveCharWidth;
3962   LONG tmMaxCharWidth;
3963   LONG tmWeight;
3964   LONG tmOverhang;
3965   LONG tmDigitizedAspectX;
3966   LONG tmDigitizedAspectY;
3967   CHAR tmFirstChar;
3968   CHAR tmLastChar;
3969   CHAR tmDefaultChar;
3970   CHAR tmBreakChar;
3971   BYTE tmItalic;
3972   BYTE tmUnderlined;
3973   BYTE tmStruckOut;
3974   BYTE tmPitchAndFamily;
3975   BYTE tmCharSet;
3976 } TEXTMETRICA, *LPTEXTMETRICA;
3977
3978 typedef struct tagTEXTMETRICW {
3979   LONG tmHeight;
3980   LONG tmAscent;
3981   LONG tmDescent;
3982   LONG tmInternalLeading;
3983   LONG tmExternalLeading;
3984   LONG tmAveCharWidth;
3985   LONG tmMaxCharWidth;
3986   LONG tmWeight;
3987   LONG tmOverhang;
3988   LONG tmDigitizedAspectX;
3989   LONG tmDigitizedAspectY;
3990   WCHAR tmFirstChar;
3991   WCHAR tmLastChar;
3992   WCHAR tmDefaultChar;
3993   WCHAR tmBreakChar;
3994   BYTE tmItalic;
3995   BYTE tmUnderlined;
3996   BYTE tmStruckOut;
3997   BYTE tmPitchAndFamily;
3998   BYTE tmCharSet;
3999 } TEXTMETRICW, *LPTEXTMETRICW;
4000
4001 typedef_tident(TEXTMETRIC)
4002 typedef_tident(LPTEXTMETRIC)
4003
4004 typedef struct _OUTLINETEXTMETRICA {
4005   UINT   otmSize;
4006   TEXTMETRICA otmTextMetrics;
4007   BYTE   otmFiller;
4008   PANOSE otmPanoseNumber;
4009   UINT   otmfsSelection;
4010   UINT   otmfsType;
4011   int    otmsCharSlopeRise;
4012   int    otmsCharSlopeRun;
4013   int    otmItalicAngle;
4014   UINT   otmEMSquare;
4015   int    otmAscent;
4016   int    otmDescent;
4017   UINT   otmLineGap;
4018   UINT   otmsCapEmHeight;
4019   UINT   otmsXHeight;
4020   RECT   otmrcFontBox;
4021   int    otmMacAscent;
4022   int    otmMacDescent;
4023   UINT   otmMacLineGap;
4024   UINT   otmusMinimumPPEM;
4025   POINT  otmptSubscriptSize;
4026   POINT  otmptSubscriptOffset;
4027   POINT  otmptSuperscriptSize;
4028   POINT  otmptSuperscriptOffset;
4029   UINT   otmsStrikeoutSize;
4030   int    otmsStrikeoutPosition;
4031   int    otmsUnderscoreSize;
4032   int    otmsUnderscorePosition;
4033   PSTR   otmpFamilyName;
4034   PSTR   otmpFaceName;
4035   PSTR   otmpStyleName;
4036   PSTR   otmpFullName;
4037 } OUTLINETEXTMETRICA, *LPOUTLINETEXTMETRICA;
4038
4039 typedef struct _OUTLINETEXTMETRICW {
4040   UINT   otmSize;
4041   TEXTMETRICW otmTextMetrics;
4042   BYTE   otmFiller;
4043   PANOSE otmPanoseNumber;
4044   UINT   otmfsSelection;
4045   UINT   otmfsType;
4046   int    otmsCharSlopeRise;
4047   int    otmsCharSlopeRun;
4048   int    otmItalicAngle;
4049   UINT   otmEMSquare;
4050   int    otmAscent;
4051   int    otmDescent;
4052   UINT   otmLineGap;
4053   UINT   otmsCapEmHeight;
4054   UINT   otmsXHeight;
4055   RECT   otmrcFontBox;
4056   int    otmMacAscent;
4057   int    otmMacDescent;
4058   UINT   otmMacLineGap;
4059   UINT   otmusMinimumPPEM;
4060   POINT  otmptSubscriptSize;
4061   POINT  otmptSubscriptOffset;
4062   POINT  otmptSuperscriptSize;
4063   POINT  otmptSuperscriptOffset;
4064   UINT   otmsStrikeoutSize;
4065   int    otmsStrikeoutPosition;
4066   int    otmsUnderscoreSize;
4067   int    otmsUnderscorePosition;
4068   PSTR   otmpFamilyName;
4069   PSTR   otmpFaceName;
4070   PSTR   otmpStyleName;
4071   PSTR   otmpFullName;
4072 } OUTLINETEXTMETRICW, *LPOUTLINETEXTMETRICW;
4073
4074 typedef_tident(OUTLINETEXTMETRIC)
4075 typedef_tident(LPOUTLINETEXTMETRIC)
4076
4077 typedef struct _OVERLAPPED {
4078   DWORD  Internal;
4079   DWORD  InternalHigh;
4080   DWORD  Offset;
4081   DWORD  OffsetHigh;
4082   HANDLE hEvent;
4083 } OVERLAPPED, *LPOVERLAPPED;
4084
4085 typedef struct tagPSDA {
4086     DWORD           lStructSize;
4087     HWND            hwndOwner;
4088     HGLOBAL         hDevMode;
4089     HGLOBAL         hDevNames;
4090     DWORD           Flags;
4091     POINT           ptPaperSize;
4092     RECT            rtMinMargin;
4093     RECT            rtMargin;
4094     HINSTANCE       hInstance;
4095     LPARAM          lCustData;
4096     LPPAGESETUPHOOK lpfnPageSetupHook;
4097     LPPAGEPAINTHOOK lpfnPagePaintHook;
4098     LPCSTR          lpPageSetupTemplateName;
4099     HGLOBAL         hPageSetupTemplate;
4100 } PAGESETUPDLGA, *LPPAGESETUPDLGA;
4101
4102 typedef struct tagPSDW {
4103     DWORD           lStructSize;
4104     HWND            hwndOwner;
4105     HGLOBAL         hDevMode;
4106     HGLOBAL         hDevNames;
4107     DWORD           Flags;
4108     POINT           ptPaperSize;
4109     RECT            rtMinMargin;
4110     RECT            rtMargin;
4111     HINSTANCE       hInstance;
4112     LPARAM          lCustData;
4113     LPPAGESETUPHOOK lpfnPageSetupHook;
4114     LPPAGEPAINTHOOK lpfnPagePaintHook;
4115     LPCWSTR         lpPageSetupTemplateName;
4116     HGLOBAL         hPageSetupTemplate;
4117 } PAGESETUPDLGW, *LPPAGESETUPDLGW;
4118
4119 typedef_tident(PAGESETUPDLG)
4120 typedef_tident(LPPAGESETUPDLG)
4121
4122 typedef struct tagPAINTSTRUCT {
4123   HDC  hdc;
4124   WINBOOL fErase;
4125   RECT rcPaint;
4126   WINBOOL fRestore;
4127   WINBOOL fIncUpdate;
4128   BYTE rgbReserved[32];
4129 } PAINTSTRUCT, *LPPAINTSTRUCT;
4130
4131 typedef struct _paraformat {
4132   UINT cbSize;
4133   DWORD dwMask;
4134   WORD  wNumbering;
4135   WORD  wReserved;
4136   LONG  dxStartIndent;
4137   LONG  dxRightIndent;
4138   LONG  dxOffset;
4139   WORD  wAlignment;
4140   SHORT cTabCount;
4141   LONG  rgxTabs[MAX_TAB_STOPS];
4142 } PARAFORMAT;
4143
4144 typedef struct _PERF_COUNTER_BLOCK {
4145   DWORD ByteLength;
4146 } PERF_COUNTER_BLOCK;
4147
4148 typedef struct _PERF_COUNTER_DEFINITION {
4149   DWORD  ByteLength;
4150   DWORD  CounterNameTitleIndex;
4151   LPWSTR CounterNameTitle;
4152   DWORD  CounterHelpTitleIndex;
4153   LPWSTR CounterHelpTitle;
4154   DWORD  DefaultScale;
4155   DWORD  DetailLevel;
4156   DWORD  CounterType;
4157   DWORD  CounterSize;
4158   DWORD  CounterOffset;
4159 } PERF_COUNTER_DEFINITION;
4160
4161 typedef struct _PERF_DATA_BLOCK {
4162   WCHAR         Signature[4];
4163   DWORD         LittleEndian;
4164   DWORD         Version;
4165   DWORD         Revision;
4166   DWORD         TotalByteLength;
4167   DWORD         HeaderLength;
4168   DWORD         NumObjectTypes;
4169   DWORD         DefaultObject;
4170   SYSTEMTIME    SystemTime;
4171   LARGE_INTEGER PerfTime;
4172   LARGE_INTEGER PerfFreq;
4173   LARGE_INTEGER PerfTime100nSec;
4174   DWORD         SystemNameLength;
4175   DWORD         SystemNameOffset;
4176 } PERF_DATA_BLOCK;
4177
4178 typedef struct _PERF_INSTANCE_DEFINITION {
4179   DWORD ByteLength;
4180   DWORD ParentObjectTitleIndex;
4181   DWORD ParentObjectInstance;
4182   DWORD UniqueID;
4183   DWORD NameOffset;
4184   DWORD NameLength;
4185 } PERF_INSTANCE_DEFINITION;
4186
4187 typedef struct _PERF_OBJECT_TYPE {
4188   DWORD  TotalByteLength;
4189   DWORD  DefinitionLength;
4190   DWORD  HeaderLength;
4191   DWORD  ObjectNameTitleIndex;
4192   LPWSTR ObjectNameTitle;
4193   DWORD  ObjectHelpTitleIndex;
4194   LPWSTR ObjectHelpTitle;
4195   DWORD  DetailLevel;
4196   DWORD  NumCounters;
4197   DWORD  DefaultCounter;
4198   DWORD  NumInstances;
4199   DWORD  CodePage;
4200   LARGE_INTEGER PerfTime;
4201   LARGE_INTEGER PerfFreq;
4202 } PERF_OBJECT_TYPE;
4203
4204 typedef struct _POLYTEXTA {
4205   int     x;
4206   int     y;
4207   UINT    n;
4208   LPCSTR  lpstr;
4209   UINT    uiFlags;
4210   RECT    rcl;
4211   int     *pdx;
4212 } POLYTEXTA, *LPPOLYTEXTA;
4213
4214 typedef struct _POLYTEXTW {
4215   int     x;
4216   int     y;
4217   UINT    n;
4218   LPCWSTR lpstr;
4219   UINT    uiFlags;
4220   RECT    rcl;
4221   int     *pdx;
4222 } POLYTEXTW, *LPPOLYTEXTW;
4223
4224 typedef_tident(POLYTEXT)
4225 typedef_tident(LPPOLYTEXT)
4226
4227 typedef struct _PORT_INFO_1A {
4228   LPSTR  pName;
4229 } PORT_INFO_1A;
4230
4231 typedef struct _PORT_INFO_1W {
4232   LPWSTR pName;
4233 } PORT_INFO_1W;
4234
4235 typedef_tident(PORT_INFO_1)
4236
4237 typedef struct _PORT_INFO_2A {
4238   LPSTR  pPortName;
4239   LPSTR  pMonitorName;
4240   LPSTR  pDescription;
4241   DWORD  fPortType;
4242   DWORD  Reserved;
4243 } PORT_INFO_2A;
4244
4245 typedef struct _PORT_INFO_2W {
4246   LPWSTR pPortName;
4247   LPWSTR pMonitorName;
4248   LPWSTR pDescription;
4249   DWORD  fPortType;
4250   DWORD  Reserved;
4251 } PORT_INFO_2W;
4252
4253 typedef_tident(PORT_INFO_2)
4254
4255 typedef struct _PREVENT_MEDIA_REMOVAL {
4256   BOOLEAN PreventMediaRemoval;
4257 } PREVENT_MEDIA_REMOVAL ;
4258
4259
4260 #include <pshpack1.h>
4261
4262 typedef struct tagPDA {
4263   DWORD     lStructSize;
4264   HWND      hwndOwner;
4265   HANDLE    hDevMode;
4266   HANDLE    hDevNames;
4267   HDC       hDC;
4268   DWORD     Flags;
4269   WORD      nFromPage;
4270   WORD      nToPage;
4271   WORD      nMinPage;
4272   WORD      nMaxPage;
4273   WORD      nCopies;
4274   HINSTANCE hInstance;
4275   DWORD     lCustData;
4276   LPPRINTHOOKPROC lpfnPrintHook;
4277   LPSETUPHOOKPROC lpfnSetupHook;
4278   LPCSTR    lpPrintTemplateName;
4279   LPCSTR    lpSetupTemplateName;
4280   HANDLE    hPrintTemplate;
4281   HANDLE    hSetupTemplate;
4282 } PRINTDLGA, *LPPRINTDLGA;
4283
4284 typedef struct tagPDW {
4285   DWORD     lStructSize;
4286   HWND      hwndOwner;
4287   HANDLE    hDevMode;
4288   HANDLE    hDevNames;
4289   HDC       hDC;
4290   DWORD     Flags;
4291   WORD      nFromPage;
4292   WORD      nToPage;
4293   WORD      nMinPage;
4294   WORD      nMaxPage;
4295   WORD      nCopies;
4296   HINSTANCE hInstance;
4297   DWORD     lCustData;
4298   LPPRINTHOOKPROC lpfnPrintHook;
4299   LPSETUPHOOKPROC lpfnSetupHook;
4300   LPCWSTR   lpPrintTemplateName;
4301   LPCWSTR   lpSetupTemplateName;
4302   HANDLE    hPrintTemplate;
4303   HANDLE    hSetupTemplate;
4304 } PRINTDLGW, *LPPRINTDLGW;
4305
4306 #include <poppack.h>
4307
4308
4309 typedef_tident(PRINTDLG)
4310 typedef_tident(LPPRINTDLG)
4311
4312 typedef struct _PRINTER_DEFAULTSA
4313 {
4314   LPSTR       pDatatype;
4315   LPDEVMODEA  pDevMode;
4316   ACCESS_MASK DesiredAccess;
4317 } PRINTER_DEFAULTSA, *PPRINTER_DEFAULTSA, *LPPRINTER_DEFAULTSA;
4318
4319 typedef struct _PRINTER_DEFAULTSW
4320 {
4321   LPWSTR      pDatatype;
4322   LPDEVMODEW  pDevMode;
4323   ACCESS_MASK DesiredAccess;
4324 } PRINTER_DEFAULTSW, *PPRINTER_DEFAULTSW, *LPPRINTER_DEFAULTSW;
4325
4326 typedef_tident(PRINTER_DEFAULTS)
4327 typedef_tident(PPRINTER_DEFAULTS)
4328 typedef_tident(LPPRINTER_DEFAULTS)
4329
4330 typedef struct _PRINTER_INFO_1A {
4331   DWORD  Flags;
4332   LPSTR  pDescription;
4333   LPSTR  pName;
4334   LPSTR  pComment;
4335 } PRINTER_INFO_1A, *PPRINTER_INFO_1A, *LPPRINTER_INFO_1A;
4336
4337 typedef struct _PRINTER_INFO_1W {
4338   DWORD  Flags;
4339   LPWSTR pDescription;
4340   LPWSTR pName;
4341   LPWSTR pComment;
4342 } PRINTER_INFO_1W, *PPRINTER_INFO_1W, *LPPRINTER_INFO_1W;
4343
4344 typedef_tident(PRINTER_INFO_1)
4345 typedef_tident(PPRINTER_INFO_1)
4346 typedef_tident(LPPRINTER_INFO_1)
4347
4348 #if 0
4349 typedef struct _PRINTER_INFO_2A {
4350   LPSTR      pServerName;
4351   LPSTR      pPrinterName;
4352   LPSTR      pShareName;
4353   LPSTR      pPortName;
4354   LPSTR      pDriverName;
4355   LPSTR      pComment;
4356   LPSTR      pLocation;
4357   LPDEVMODEA pDevMode;
4358   LPSTR      pSepFile;
4359   LPSTR      pPrintProcessor;
4360   LPSTR      pDatatype;
4361   LPSTR      pParameters;
4362   PSECURITY_DESCRIPTOR pSecurityDescriptor;
4363   DWORD      Attributes;
4364   DWORD      Priority;
4365   DWORD      DefaultPriority;
4366   DWORD      StartTime;
4367   DWORD      UntilTime;
4368   DWORD      Status;
4369   DWORD      cJobs;
4370   DWORD      AveragePPM;
4371 } PRINTER_INFO_2A;
4372
4373 typedef struct _PRINTER_INFO_2W {
4374   LPWSTR     pServerName;
4375   LPWSTR     pPrinterName;
4376   LPWSTR     pShareName;
4377   LPWSTR     pPortName;
4378   LPWSTR     pDriverName;
4379   LPWSTR     pComment;
4380   LPWSTR     pLocation;
4381   LPDEVMODEW pDevMode;
4382   LPWSTR     pSepFile;
4383   LPWSTR     pPrintProcessor;
4384   LPWSTR     pDatatype;
4385   LPWSTR     pParameters;
4386   PSECURITY_DESCRIPTOR pSecurityDescriptor;
4387   DWORD      Attributes;
4388   DWORD      Priority;
4389   DWORD      DefaultPriority;
4390   DWORD      StartTime;
4391   DWORD      UntilTime;
4392   DWORD      Status;
4393   DWORD      cJobs;
4394   DWORD      AveragePPM;
4395 } PRINTER_INFO_2W;
4396
4397 typedef_tident(PRINTER_INFO_2)
4398
4399 typedef struct _PRINTER_INFO_3 {
4400   PSECURITY_DESCRIPTOR pSecurityDescriptor;
4401 } PRINTER_INFO_3;
4402 #endif
4403
4404 typedef struct _PRINTER_INFO_4A {
4405   LPSTR  pPrinterName;
4406   LPSTR  pServerName;
4407   DWORD  Attributes;
4408 } PRINTER_INFO_4A;
4409
4410 typedef struct _PRINTER_INFO_4W {
4411   LPWSTR pPrinterName;
4412   LPWSTR pServerName;
4413   DWORD  Attributes;
4414 } PRINTER_INFO_4W;
4415
4416 typedef_tident(PRINTER_INFO_4)
4417
4418 typedef struct _PRINTER_INFO_5A {
4419   LPSTR     pPrinterName;
4420   LPSTR     pPortName;
4421   DWORD     Attributes;
4422   DWORD     DeviceNotSelectedTimeout;
4423   DWORD     TransmissionRetryTimeout;
4424 } PRINTER_INFO_5A;
4425
4426 typedef struct _PRINTER_INFO_5W {
4427   LPWSTR    pPrinterName;
4428   LPWSTR    pPortName;
4429   DWORD     Attributes;
4430   DWORD     DeviceNotSelectedTimeout;
4431   DWORD     TransmissionRetryTimeout;
4432 } PRINTER_INFO_5W;
4433
4434 typedef_tident(PRINTER_INFO_5)
4435
4436 typedef struct _PRINTER_NOTIFY_INFO_DATA {
4437   WORD   Type;
4438   WORD   Field;
4439   DWORD  Reserved;
4440   DWORD  Id;
4441   union {
4442     DWORD  adwData[2];
4443     struct {
4444       DWORD  cbBuf;
4445       LPVOID pBuf;
4446     } Data;
4447   } NotifyData;
4448 } PRINTER_NOTIFY_INFO_DATA;
4449
4450 typedef struct _PRINTER_NOTIFY_INFO {
4451   DWORD  Version;
4452   DWORD  Flags;
4453   DWORD  Count;
4454   PRINTER_NOTIFY_INFO_DATA  aData[1];
4455 } PRINTER_NOTIFY_INFO;
4456
4457 typedef struct _PRINTER_NOTIFY_OPTIONS_TYPE {
4458   WORD   Type;
4459   WORD   Reserved0;
4460   DWORD  Reserved1;
4461   DWORD  Reserved2;
4462   DWORD  Count;
4463   PWORD  pFields;
4464 } PRINTER_NOTIFY_OPTIONS_TYPE, *PPRINTER_NOTIFY_OPTIONS_TYPE;
4465
4466 typedef struct _PRINTER_NOTIFY_OPTIONS {
4467   DWORD  Version;
4468   DWORD  Flags;
4469   DWORD  Count;
4470   PPRINTER_NOTIFY_OPTIONS_TYPE  pTypes;
4471 } PRINTER_NOTIFY_OPTIONS;
4472
4473 typedef struct _PRINTPROCESSOR_INFO_1A {
4474   LPSTR  pName;
4475 } PRINTPROCESSOR_INFO_1A;
4476
4477 typedef struct _PRINTPROCESSOR_INFO_1W {
4478   LPWSTR pName;
4479 } PRINTPROCESSOR_INFO_1W;
4480
4481 typedef_tident(PRINTPROCESSOR_INFO_1)
4482
4483 typedef struct _PROCESS_HEAP_ENTRY {
4484   PVOID lpData;
4485   DWORD cbData;
4486   BYTE cbOverhead;
4487   BYTE iRegionIndex;
4488   WORD wFlags;
4489   DWORD dwCommittedSize;
4490   DWORD dwUnCommittedSize;
4491   LPVOID lpFirstBlock;
4492   LPVOID lpLastBlock;
4493   HANDLE hMem;
4494 } PROCESS_HEAPENTRY, *LPPROCESS_HEAP_ENTRY;
4495
4496 typedef struct _PROCESS_INFORMATION {
4497   HANDLE hProcess;
4498   HANDLE hThread;
4499   DWORD dwProcessId;
4500   DWORD dwThreadId;
4501 } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
4502
4503 typedef UINT (CALLBACK *LPFNPSPCALLBACK) (HWND, UINT, LPVOID);
4504
4505 typedef struct _PROPSHEETPAGEA {
4506   DWORD     dwSize;
4507   DWORD     dwFlags;
4508   HINSTANCE hInstance;
4509   union {
4510     LPCSTR         pszTemplate;
4511     LPCDLGTEMPLATE pResource;
4512   } u1;
4513   union {
4514     HICON   hIcon;
4515     LPCSTR  pszIcon;
4516   } u2;
4517   LPCSTR  pszTitle;
4518   DLGPROC pfnDlgProc;
4519   LPARAM  lParam;
4520   LPFNPSPCALLBACK pfnCallback;
4521   UINT   * pcRefParent;
4522 } PROPSHEETPAGEA, *LPPROPSHEETPAGEA;
4523 typedef const PROPSHEETPAGEA* LPCPROPSHEETPAGEA;
4524
4525 typedef struct _PROPSHEETPAGEW {
4526   DWORD     dwSize;
4527   DWORD     dwFlags;
4528   HINSTANCE hInstance;
4529   union {
4530     LPCWSTR        pszTemplate;
4531     LPCDLGTEMPLATE pResource;
4532   } u1;
4533   union {
4534     HICON   hIcon;
4535     LPCWSTR pszIcon;
4536   } u2;
4537   LPCWSTR pszTitle;
4538   DLGPROC pfnDlgProc;
4539   LPARAM  lParam;
4540   LPFNPSPCALLBACK pfnCallback;
4541   UINT   * pcRefParent;
4542 } PROPSHEETPAGEW, *LPPROPSHEETPAGEW;
4543 typedef const PROPSHEETPAGEW* LPCPROPSHEETPAGEW;
4544
4545 typedef_tident(PROPSHEETPAGE)
4546 typedef_tident(LPPROPSHEETPAGE)
4547 typedef_tident(LPCPROPSHEETPAGE)
4548
4549 typedef struct _PSP *HPROPSHEETPAGE;
4550
4551 typedef struct _PROPSHEETHEADERA {
4552   DWORD      dwSize;
4553   DWORD      dwFlags;
4554   HWND       hwndParent;
4555   HINSTANCE  hInstance;
4556   union {
4557     HICON   hIcon;
4558     LPCSTR  pszIcon;
4559   } u1;
4560   LPCSTR     pszCaption;
4561   UINT       nPages;
4562   union {
4563     UINT    nStartPage;
4564     LPCSTR  pStartPage;
4565   } u2;
4566   union {
4567     LPCPROPSHEETPAGEA  ppsp;
4568     HPROPSHEETPAGE    *phpage;
4569   } u3;
4570   PFNPROPSHEETCALLBACK pfnCallback;
4571 } PROPSHEETHEADERA, *LPPROPSHEETHEADERA;
4572 typedef const PROPSHEETHEADERA *LPCPROPSHEETHEADERA;
4573
4574 typedef struct _PROPSHEETHEADERW {
4575   DWORD      dwSize;
4576   DWORD      dwFlags;
4577   HWND       hwndParent;
4578   HINSTANCE  hInstance;
4579   union {
4580     HICON   hIcon;
4581     LPCWSTR pszIcon;
4582   } u1;
4583   LPCWSTR    pszCaption;
4584   UINT       nPages;
4585   union {
4586     UINT    nStartPage;
4587     LPCWSTR pStartPage;
4588   } u2;
4589   union {
4590     LPCPROPSHEETPAGEW  ppsp;
4591     HPROPSHEETPAGE    *phpage;
4592   } u3;
4593   PFNPROPSHEETCALLBACK pfnCallback;
4594 } PROPSHEETHEADERW, *LPPROPSHEETHEADERW;
4595 typedef const PROPSHEETHEADERW *LPCPROPSHEETHEADERW;
4596
4597 typedef_tident(PROPSHEETHEADER)
4598 typedef_tident(LPPROPSHEETHEADER)
4599 typedef_tident(LPCPROPSHEETHEADER)
4600
4601 /* PropertySheet callbacks */
4602 typedef WINBOOL (CALLBACK *LPFNADDPROPSHEETPAGE) (HPROPSHEETPAGE, LPARAM);
4603 typedef WINBOOL (CALLBACK *LPFNADDPROPSHEETPAGES) (LPVOID,
4604                                                    LPFNADDPROPSHEETPAGE,
4605                                                    LPARAM);
4606
4607 typedef  struct _PROTOCOL_INFOA {
4608   DWORD  dwServiceFlags;
4609   INT  iAddressFamily;
4610   INT  iMaxSockAddr;
4611   INT  iMinSockAddr;
4612   INT  iSocketType;
4613   INT  iProtocol;
4614   DWORD  dwMessageSize;
4615   LPSTR  lpProtocol;
4616 } PROTOCOL_INFOA;
4617
4618 typedef  struct _PROTOCOL_INFOW {
4619   DWORD  dwServiceFlags;
4620   INT  iAddressFamily;
4621   INT  iMaxSockAddr;
4622   INT  iMinSockAddr;
4623   INT  iSocketType;
4624   INT  iProtocol;
4625   DWORD  dwMessageSize;
4626   LPWSTR  lpProtocol;
4627 } PROTOCOL_INFOW;
4628
4629 typedef_tident(PROTOCOL_INFO)
4630
4631 typedef struct _PROVIDOR_INFO_1A {
4632   LPSTR  pName;
4633   LPSTR  pEnvironment ;
4634   LPSTR  pDLLName ;
4635 } PROVIDOR_INFO_1A;
4636
4637 typedef struct _PROVIDOR_INFO_1W {
4638   LPWSTR pName;
4639   LPWSTR pEnvironment ;
4640   LPWSTR pDLLName ;
4641 } PROVIDOR_INFO_1W;
4642
4643 typedef_tident(PROVIDOR_INFO_1)
4644
4645 typedef struct _PSHNOTIFY {
4646   NMHDR hdr;
4647   LPARAM lParam;
4648 } PSHNOTIFY,   *LPPSHNOTIFY;
4649
4650 typedef struct _punctuationA {
4651   UINT   iSize;
4652   LPSTR  szPunctuation;
4653 } PUNCTUATIONA;
4654
4655 typedef struct _punctuationW {
4656   UINT   iSize;
4657   LPWSTR szPunctuation;
4658 } PUNCTUATIONW;
4659
4660 typedef_tident(PUNCTUATION)
4661
4662 typedef struct _QUERY_SERVICE_CONFIGA {
4663   DWORD dwServiceType;
4664   DWORD dwStartType;
4665   DWORD dwErrorControl;
4666   LPSTR lpBinaryPathName;
4667   LPSTR lpLoadOrderGroup;
4668   DWORD dwTagId;
4669   LPSTR lpDependencies;
4670   LPSTR lpServiceStartName;
4671   LPSTR lpDisplayName;
4672 } QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
4673
4674 typedef struct _QUERY_SERVICE_CONFIGW {
4675   DWORD dwServiceType;
4676   DWORD dwStartType;
4677   DWORD dwErrorControl;
4678   LPWSTR lpBinaryPathName;
4679   LPWSTR lpLoadOrderGroup;
4680   DWORD dwTagId;
4681   LPWSTR lpDependencies;
4682   LPWSTR lpServiceStartName;
4683   LPWSTR lpDisplayName;
4684 } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
4685
4686 typedef_tident(QUERY_SERVICE_CONFIG)
4687 typedef_tident(LPQUERY_SERVICE_CONFIG)
4688
4689 typedef struct _QUERY_SERVICE_LOCK_STATUSA {
4690   DWORD fIsLocked;
4691   LPSTR lpLockOwner;
4692   DWORD dwLockDuration;
4693 } QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
4694
4695 typedef struct _QUERY_SERVICE_LOCK_STATUSW {
4696   DWORD fIsLocked;
4697   LPWSTR lpLockOwner;
4698   DWORD dwLockDuration;
4699 } QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;
4700
4701 typedef_tident(QUERY_SERVICE_LOCK_STATUS)
4702 typedef_tident(LPQUERY_SERVICE_LOCK_STATUS)
4703
4704 typedef  struct  _RASAMBA {
4705   DWORD    dwSize;
4706   DWORD    dwError;
4707   CHAR     szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4708   BYTE     bLana;
4709 } RASAMBA;
4710
4711 typedef  struct  _RASAMBW {
4712   DWORD    dwSize;
4713   DWORD    dwError;
4714   WCHAR    szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4715   BYTE     bLana;
4716 } RASAMBW;
4717
4718 typedef_tident(RASAMB)
4719
4720 typedef struct _RASCONNA {
4721   DWORD     dwSize;
4722   HRASCONN  hrasconn;
4723   CHAR      szEntryName[RAS_MaxEntryName + 1];
4724
4725   /* WINVER >= 0x400 */
4726   CHAR      szDeviceType[ RAS_MaxDeviceType + 1 ];
4727   CHAR      szDeviceName[ RAS_MaxDeviceName + 1 ];
4728
4729   /* WINVER >= 0x401 */
4730   CHAR      szPhonebook[ MAX_PATH ];
4731   DWORD     dwSubEntry;
4732
4733   /* WINVER >= 0x500 */
4734   GUID      guidEntry;
4735
4736   /* WINVER >= 0x501 */
4737   DWORD     dwSessionId;
4738   DWORD     dwFlags;
4739   LUID      luid;
4740 } RASCONNA ;
4741
4742 typedef struct _RASCONNW {
4743   DWORD     dwSize;
4744   HRASCONN  hrasconn;
4745   WCHAR     szEntryName[RAS_MaxEntryName + 1];
4746
4747   /* WINVER >= 0x400 */
4748   WCHAR     szDeviceType[ RAS_MaxDeviceType + 1 ];
4749   WCHAR     szDeviceName[ RAS_MaxDeviceName + 1 ];
4750
4751   /* WINVER >= 0x401 */
4752   WCHAR     szPhonebook[ MAX_PATH ];
4753   DWORD     dwSubEntry;
4754
4755   /* WINVER >= 0x500 */
4756   GUID      guidEntry;
4757
4758   /* WINVER >= 0x501 */
4759   DWORD     dwSessionId;
4760   DWORD     dwFlags;
4761   LUID      luid;
4762 } RASCONNW ;
4763
4764 typedef_tident(RASCONN)
4765
4766 typedef struct _RASCONNSTATUSA {
4767   DWORD         dwSize;
4768   RASCONNSTATE  rasconnstate;
4769   DWORD         dwError;
4770   CHAR          szDeviceType[RAS_MaxDeviceType + 1];
4771   CHAR          szDeviceName[RAS_MaxDeviceName + 1];
4772 } RASCONNSTATUSA;
4773
4774 typedef struct _RASCONNSTATUSW {
4775   DWORD         dwSize;
4776   RASCONNSTATE  rasconnstate;
4777   DWORD         dwError;
4778   WCHAR         szDeviceType[RAS_MaxDeviceType + 1];
4779   WCHAR         szDeviceName[RAS_MaxDeviceName + 1];
4780 } RASCONNSTATUSW;
4781
4782 typedef_tident(RASCONNSTATUS)
4783
4784 typedef  struct  _RASDIALEXTENSIONS {
4785   DWORD    dwSize;
4786   DWORD    dwfOptions;
4787   HWND     hwndParent;
4788   DWORD    reserved;
4789 } RASDIALEXTENSIONS;
4790
4791 typedef struct _RASDIALPARAMSA {
4792   DWORD  dwSize;
4793   CHAR   szEntryName[RAS_MaxEntryName + 1];
4794   CHAR   szPhoneNumber[RAS_MaxPhoneNumber + 1];
4795   CHAR   szCallbackNumber[RAS_MaxCallbackNumber + 1];
4796   CHAR   szUserName[UNLEN + 1];
4797   CHAR   szPassword[PWLEN + 1];
4798   CHAR   szDomain[DNLEN + 1] ;
4799 } RASDIALPARAMSA;
4800
4801 typedef struct _RASDIALPARAMSW {
4802   DWORD  dwSize;
4803   WCHAR  szEntryName[RAS_MaxEntryName + 1];
4804   WCHAR  szPhoneNumber[RAS_MaxPhoneNumber + 1];
4805   WCHAR  szCallbackNumber[RAS_MaxCallbackNumber + 1];
4806   WCHAR  szUserName[UNLEN + 1];
4807   WCHAR  szPassword[PWLEN + 1];
4808   WCHAR  szDomain[DNLEN + 1] ;
4809 } RASDIALPARAMSW;
4810
4811 typedef_tident(RASDIALPARAMS)
4812
4813 typedef struct _RASENTRYNAMEA {
4814   DWORD  dwSize;
4815   CHAR   szEntryName[RAS_MaxEntryName + 1];
4816 }RASENTRYNAMEA;
4817
4818 typedef struct _RASENTRYNAMEW {
4819   DWORD  dwSize;
4820   WCHAR  szEntryName[RAS_MaxEntryName + 1];
4821 }RASENTRYNAMEW;
4822
4823 typedef_tident(RASENTRYNAME)
4824
4825 typedef  struct  _RASPPPIPA {
4826   DWORD    dwSize;
4827   DWORD    dwError;
4828   CHAR     szIpAddress[ RAS_MaxIpAddress + 1 ];
4829 } RASPPPIPA;
4830
4831 typedef  struct  _RASPPPIPW {
4832   DWORD    dwSize;
4833   DWORD    dwError;
4834   WCHAR    szIpAddress[ RAS_MaxIpAddress + 1 ];
4835 } RASPPPIPW;
4836
4837 typedef_tident(RASPPPIP)
4838
4839 typedef  struct  _RASPPPIPXA {
4840   DWORD    dwSize;
4841   DWORD    dwError;
4842   CHAR     szIpxAddress[ RAS_MaxIpxAddress + 1 ];
4843 } RASPPPIPXA;
4844
4845 typedef  struct  _RASPPPIPXW {
4846   DWORD    dwSize;
4847   DWORD    dwError;
4848   WCHAR    szIpxAddress[ RAS_MaxIpxAddress + 1 ];
4849 } RASPPPIPXW;
4850
4851 typedef_tident(RASPPPIPX)
4852
4853 typedef  struct  _RASPPPNBFA {
4854   DWORD    dwSize;
4855   DWORD    dwError;
4856   DWORD    dwNetBiosError;
4857   CHAR     szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4858   CHAR     szWorkstationName[ NETBIOS_NAME_LEN + 1 ];
4859   BYTE     bLana;
4860 } RASPPPNBFA;
4861
4862 typedef  struct  _RASPPPNBFW {
4863   DWORD    dwSize;
4864   DWORD    dwError;
4865   DWORD    dwNetBiosError;
4866   WCHAR    szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4867   WCHAR    szWorkstationName[ NETBIOS_NAME_LEN + 1 ];
4868   BYTE     bLana;
4869 } RASPPPNBFW;
4870
4871 typedef_tident(RASPPPNBF)
4872
4873 typedef struct _RASTERIZER_STATUS {
4874   short nSize;
4875   short wFlags;
4876   short nLanguageID;
4877 } RASTERIZER_STATUS, *LPRASTERIZER_STATUS;
4878
4879 typedef struct _REASSIGN_BLOCKS {
4880   WORD   Reserved;
4881   WORD   Count;
4882   DWORD BlockNumber[1];
4883 } REASSIGN_BLOCKS ;
4884
4885 typedef struct _REMOTE_NAME_INFOA {
4886   LPSTR   lpUniversalName;
4887   LPSTR   lpConnectionName;
4888   LPSTR   lpRemainingPath;
4889 } REMOTE_NAME_INFOA;
4890
4891 typedef struct _REMOTE_NAME_INFOW {
4892   LPWSTR  lpUniversalName;
4893   LPWSTR  lpConnectionName;
4894   LPWSTR  lpRemainingPath;
4895 } REMOTE_NAME_INFOW;
4896
4897 typedef_tident(REMOTE_NAME_INFO)
4898
4899 /*
4900  TODO: OLE
4901 typedef struct _reobject {
4902   DWORD  cbStruct;
4903   LONG   cp;
4904   CLSID  clsid;
4905   LPOLEOBJECT      poleobj;
4906   LPSTORAGE        pstg;
4907   LPOLECLIENTSITE  polesite;
4908   SIZEL  sizel;
4909   DWORD  dvaspect;
4910   DWORD  dwFlags;
4911   DWORD  dwUser;
4912 } REOBJECT;
4913 */
4914
4915 typedef struct _repastespecial {
4916   DWORD  dwAspect;
4917   DWORD  dwParam;
4918 } REPASTESPECIAL;
4919
4920 typedef struct _reqresize {
4921   NMHDR nmhdr;
4922   RECT rc;
4923 } REQRESIZE;
4924
4925 typedef struct _RGNDATAHEADER {
4926   DWORD dwSize;
4927   DWORD iType;
4928   DWORD nCount;
4929   DWORD nRgnSize;
4930   RECT  rcBound;
4931 } RGNDATAHEADER;
4932
4933 typedef struct _RGNDATA {
4934   RGNDATAHEADER rdh;
4935   char          Buffer[1];
4936 } RGNDATA, *PRGNDATA, *LPRGNDATA;
4937
4938 typedef struct tagSCROLLINFO {
4939   UINT cbSize;
4940   UINT fMask;
4941   int  nMin;
4942   int  nMax;
4943   UINT nPage;
4944   int  nPos;
4945   int  nTrackPos;
4946 }   SCROLLINFO, *LPSCROLLINFO;
4947 typedef SCROLLINFO const *LPCSCROLLINFO;
4948
4949
4950 typedef struct _selchange {
4951   NMHDR nmhdr;
4952   CHARRANGE chrg;
4953   WORD seltyp;
4954 } SELCHANGE;
4955
4956 typedef struct tagSERIALKEYS {
4957   DWORD cbSize;
4958   DWORD dwFlags;
4959   LPSTR lpszActivePort;
4960   LPSTR lpszPort;
4961   DWORD iBaudRate;
4962   DWORD iPortState;
4963 } SERIALKEYS,  * LPSERIALKEYS;
4964
4965 typedef struct _SERVICE_TABLE_ENTRYA {
4966   LPSTR lpServiceName;
4967   LPSERVICE_MAIN_FUNCTIONA lpServiceProc;
4968 } SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
4969
4970 typedef struct _SERVICE_TABLE_ENTRYW {
4971   LPWSTR lpServiceName;
4972   LPSERVICE_MAIN_FUNCTIONW lpServiceProc;
4973 } SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
4974
4975 typedef_tident(SERVICE_TABLE_ENTRY)
4976 typedef_tident(LPSERVICE_TABLE_ENTRY)
4977
4978 typedef struct _SERVICE_TYPE_VALUE_ABSA {
4979   DWORD   dwNameSpace;
4980   DWORD   dwValueType;
4981   DWORD   dwValueSize;
4982   LPSTR   lpValueName;
4983   PVOID   lpValue;
4984 } SERVICE_TYPE_VALUE_ABSA;
4985
4986 typedef struct _SERVICE_TYPE_VALUE_ABSW {
4987   DWORD   dwNameSpace;
4988   DWORD   dwValueType;
4989   DWORD   dwValueSize;
4990   LPWSTR  lpValueName;
4991   PVOID   lpValue;
4992 } SERVICE_TYPE_VALUE_ABSW;
4993
4994 typedef_tident(SERVICE_TYPE_VALUE_ABS)
4995
4996 typedef struct _SERVICE_TYPE_INFO_ABSA {
4997   LPSTR                   lpTypeName;
4998   DWORD                   dwValueCount;
4999   SERVICE_TYPE_VALUE_ABSA Values[1];
5000 } SERVICE_TYPE_INFO_ABSA;
5001
5002 typedef struct _SERVICE_TYPE_INFO_ABSW {
5003   LPWSTR                  lpTypeName;
5004   DWORD                   dwValueCount;
5005   SERVICE_TYPE_VALUE_ABSW Values[1];
5006 } SERVICE_TYPE_INFO_ABSW;
5007
5008 typedef_tident(SERVICE_TYPE_INFO_ABS)
5009
5010 typedef struct _SESSION_BUFFER {
5011   UCHAR lsn;
5012   UCHAR state;
5013   UCHAR local_name[NCBNAMSZ];
5014   UCHAR remote_name[NCBNAMSZ];
5015   UCHAR rcvs_outstanding;
5016   UCHAR sends_outstanding;
5017 } SESSION_BUFFER;
5018
5019 typedef struct _SESSION_HEADER {
5020   UCHAR sess_name;
5021   UCHAR num_sess;
5022   UCHAR rcv_dg_outstanding;
5023   UCHAR rcv_any_outstanding;
5024 } SESSION_HEADER;
5025
5026 typedef enum tagSHCONTF {
5027   SHCONTF_FOLDERS = 32,
5028   SHCONTF_NONFOLDERS = 64,
5029   SHCONTF_INCLUDEHIDDEN = 128,
5030   SHCONTF_INIT_ON_FIRST_NEXT = 256,
5031   SHCONTF_NETPRINTERSRCH = 512,
5032   SHCONTF_SHAREABLE = 1024,
5033   SHCONTF_STORAGE = 2048
5034 } SHCONTF;
5035
5036 typedef struct _SHFILEINFO {
5037   HICON hIcon;
5038   int   iIcon;
5039   DWORD dwAttributes;
5040   char  szDisplayName[MAX_PATH];
5041   char  szTypeName[80];
5042 } SHFILEINFO;
5043
5044 typedef WORD FILEOP_FLAGS;
5045
5046 typedef struct _SHFILEOPSTRUCTA {
5047   HWND         hwnd;
5048   UINT         wFunc;
5049   LPCSTR       pFrom;
5050   LPCSTR       pTo;
5051   FILEOP_FLAGS fFlags;
5052   WINBOOL      fAnyOperationsAborted;
5053   LPVOID       hNameMappings;
5054   LPCSTR       lpszProgressTitle;
5055 } SHFILEOPSTRUCTA, *LPSHFILEOPSTRUCTA;
5056
5057 typedef struct _SHFILEOPSTRUCTW {
5058   HWND         hwnd;
5059   UINT         wFunc;
5060   LPCWSTR      pFrom;
5061   LPCWSTR      pTo;
5062   FILEOP_FLAGS fFlags;
5063   WINBOOL      fAnyOperationsAborted;
5064   LPVOID       hNameMappings;
5065   LPCWSTR      lpszProgressTitle;
5066 } SHFILEOPSTRUCTW, *LPSHFILEOPSTRUCTW;
5067
5068 typedef_tident(SHFILEOPSTRUCT)
5069 typedef_tident(LPSHFILEOPSTRUCT)
5070
5071 typedef enum tagSHGDN {
5072   SHGDN_NORMAL = 0,
5073   SHGDN_INFOLDER = 1,
5074   SHGDN_FORPARSING = 0x8000,
5075 } SHGNO;
5076
5077 typedef struct _SHNAMEMAPPINGA {
5078   LPSTR  pszOldPath;
5079   LPSTR  pszNewPath;
5080   int    cchOldPath;
5081   int    cchNewPath;
5082 } SHNAMEMAPPINGA, *LPSHNAMEMAPPINGA;
5083
5084 typedef struct _SHNAMEMAPPINGW {
5085   LPWSTR pszOldPath;
5086   LPWSTR pszNewPath;
5087   int    cchOldPath;
5088   int    cchNewPath;
5089 } SHNAMEMAPPINGW, *LPSHNAMEMAPPINGW;
5090
5091 typedef_tident(SHNAMEMAPPING)
5092 typedef_tident(LPSHNAMEMAPPING)
5093
5094 typedef struct tagSOUNDSENTRYA {
5095   UINT   cbSize;
5096   DWORD  dwFlags;
5097   DWORD  iFSTextEffect;
5098   DWORD  iFSTextEffectMSec;
5099   DWORD  iFSTextEffectColorBits;
5100   DWORD  iFSGrafEffect;
5101   DWORD  iFSGrafEffectMSec;
5102   DWORD  iFSGrafEffectColor;
5103   DWORD  iWindowsEffect;
5104   DWORD  iWindowsEffectMSec;
5105   LPSTR  lpszWindowsEffectDLL;
5106   DWORD  iWindowsEffectOrdinal;
5107 } SOUNDSENTRYA, *LPSOUNDSENTRYA;
5108
5109 typedef struct tagSOUNDSENTRYW {
5110   UINT   cbSize;
5111   DWORD  dwFlags;
5112   DWORD  iFSTextEffect;
5113   DWORD  iFSTextEffectMSec;
5114   DWORD  iFSTextEffectColorBits;
5115   DWORD  iFSGrafEffect;
5116   DWORD  iFSGrafEffectMSec;
5117   DWORD  iFSGrafEffectColor;
5118   DWORD  iWindowsEffect;
5119   DWORD  iWindowsEffectMSec;
5120   LPWSTR lpszWindowsEffectDLL;
5121   DWORD  iWindowsEffectOrdinal;
5122 } SOUNDSENTRYW, *LPSOUNDSENTRYW;
5123
5124 typedef_tident(SOUNDSENTRY)
5125 typedef_tident(LPSOUNDSENTRY)
5126
5127 typedef struct _STARTUPINFOA {
5128   DWORD   cb;
5129   LPSTR   lpReserved;
5130   LPSTR   lpDesktop;
5131   LPSTR   lpTitle;
5132   DWORD   dwX;
5133   DWORD   dwY;
5134   DWORD   dwXSize;
5135   DWORD   dwYSize;
5136   DWORD   dwXCountChars;
5137   DWORD   dwYCountChars;
5138   DWORD   dwFillAttribute;
5139   DWORD   dwFlags;
5140   WORD    wShowWindow;
5141   WORD    cbReserved2;
5142   LPBYTE  lpReserved2;
5143   HANDLE  hStdInput;
5144   HANDLE  hStdOutput;
5145   HANDLE  hStdError;
5146 } STARTUPINFOA, *LPSTARTUPINFOA;
5147
5148 typedef struct _STARTUPINFOW {
5149   DWORD   cb;
5150   LPWSTR  lpReserved;
5151   LPWSTR  lpDesktop;
5152   LPWSTR  lpTitle;
5153   DWORD   dwX;
5154   DWORD   dwY;
5155   DWORD   dwXSize;
5156   DWORD   dwYSize;
5157   DWORD   dwXCountChars;
5158   DWORD   dwYCountChars;
5159   DWORD   dwFillAttribute;
5160   DWORD   dwFlags;
5161   WORD    wShowWindow;
5162   WORD    cbReserved2;
5163   LPBYTE  lpReserved2;
5164   HANDLE  hStdInput;
5165   HANDLE  hStdOutput;
5166   HANDLE  hStdError;
5167 } STARTUPINFOW, *LPSTARTUPINFOW;
5168
5169 typedef_tident(STARTUPINFO)
5170 typedef_tident(LPSTARTUPINFO)
5171
5172 typedef struct tagSTICKYKEYS {
5173   DWORD cbSize;
5174   DWORD dwFlags;
5175 } STICKYKEYS, *LPSTICKYKEYS;
5176
5177 typedef struct _STRRET {
5178   UINT uType;
5179   union
5180     {
5181       LPWSTR pOleStr;
5182       UINT   uOffset;
5183       char   cStr[MAX_PATH];
5184     } DUMMYUNIONNAME;
5185 } STRRET, *LPSTRRET;
5186
5187 typedef struct _tagSTYLEBUF {
5188   DWORD  dwStyle;
5189   CHAR  szDescription[32];
5190 } STYLEBUF, *LPSTYLEBUF;
5191
5192 typedef struct tagSTYLESTRUCT {
5193   DWORD styleOld;
5194   DWORD styleNew;
5195 } STYLESTRUCT, * LPSTYLESTRUCT;
5196
5197 typedef struct _ACCESS_ALLOWED_ACE {
5198  ACE_HEADER Header;
5199  ACCESS_MASK Mask;
5200  DWORD SidStart;
5201 } ACCESS_ALLOWED_ACE;
5202
5203 typedef ACCESS_ALLOWED_ACE *PACCESS_ALLOWED_ACE;
5204
5205 typedef struct _ACCESS_DENIED_ACE {
5206  ACE_HEADER Header;
5207  ACCESS_MASK Mask;
5208  DWORD SidStart;
5209 } ACCESS_DENIED_ACE;
5210 typedef ACCESS_DENIED_ACE *PACCESS_DENIED_ACE;
5211
5212 typedef struct _SYSTEM_AUDIT_ACE {
5213  ACE_HEADER Header;
5214  ACCESS_MASK Mask;
5215  DWORD SidStart;
5216 } SYSTEM_AUDIT_ACE;
5217 typedef SYSTEM_AUDIT_ACE *PSYSTEM_AUDIT_ACE;
5218
5219 typedef struct _SYSTEM_ALARM_ACE {
5220  ACE_HEADER Header;
5221  ACCESS_MASK Mask;
5222  DWORD SidStart;
5223 } SYSTEM_ALARM_ACE;
5224 typedef SYSTEM_ALARM_ACE *PSYSTEM_ALARM_ACE;
5225
5226 typedef struct _ACCESS_ALLOWED_OBJECT_ACE {
5227  ACE_HEADER Header;
5228  ACCESS_MASK Mask;
5229  DWORD Flags;
5230  GUID ObjectType;
5231  GUID InheritedObjectType;
5232  DWORD SidStart;
5233 } ACCESS_ALLOWED_OBJECT_ACE, *PACCESS_ALLOWED_OBJECT_ACE;
5234
5235 typedef struct _ACCESS_DENIED_OBJECT_ACE {
5236  ACE_HEADER Header;
5237  ACCESS_MASK Mask;
5238  DWORD Flags;
5239  GUID ObjectType;
5240  GUID InheritedObjectType;
5241  DWORD SidStart;
5242 } ACCESS_DENIED_OBJECT_ACE, *PACCESS_DENIED_OBJECT_ACE;
5243
5244 typedef struct _SYSTEM_AUDIT_OBJECT_ACE {
5245  ACE_HEADER Header;
5246  ACCESS_MASK Mask;
5247  DWORD Flags;
5248  GUID ObjectType;
5249  GUID InheritedObjectType;
5250  DWORD SidStart;
5251 } SYSTEM_AUDIT_OBJECT_ACE, *PSYSTEM_AUDIT_OBJECT_ACE;
5252
5253 typedef struct _SYSTEM_ALARM_OBJECT_ACE {
5254  ACE_HEADER Header;
5255  ACCESS_MASK Mask;
5256  DWORD Flags;
5257  GUID ObjectType;
5258  GUID InheritedObjectType;
5259  DWORD SidStart;
5260 } SYSTEM_ALARM_OBJECT_ACE, *PSYSTEM_ALARM_OBJECT_ACE;
5261
5262 typedef struct _SYSTEM_INFO
5263 {
5264   union
5265     {
5266       DWORD dwOemId;
5267       struct
5268         {
5269           WORD wProcessorArchitecture;
5270           WORD wReserved;
5271         }
5272       s;
5273     }
5274   u;
5275   DWORD  dwPageSize;
5276   LPVOID lpMinimumApplicationAddress;
5277   LPVOID lpMaximumApplicationAddress;
5278   DWORD  dwActiveProcessorMask;
5279   DWORD  dwNumberOfProcessors;
5280   DWORD  dwProcessorType;
5281   DWORD  dwAllocationGranularity;
5282   WORD  wProcessorLevel;
5283   WORD  wProcessorRevision;
5284 } SYSTEM_INFO, *LPSYSTEM_INFO;
5285
5286 typedef struct _SYSTEM_POWER_STATUS {
5287   BYTE ACLineStatus;
5288   BYTE  BatteryFlag;
5289   BYTE  BatteryLifePercent;
5290   BYTE  Reserved1;
5291   DWORD  BatteryLifeTime;
5292   DWORD  BatteryFullLifeTime;
5293 } SYSTEM_POWER_STATUS;
5294 typedef SYSTEM_POWER_STATUS *LPSYSTEM_POWER_STATUS;
5295
5296 typedef struct _TAPE_CREATE_PARTITION {
5297   ULONG Method;
5298   ULONG Count;
5299   ULONG Size;
5300 } TAPE_CREATE_PARTITION, *PTAPE_CREATE_PARTITION;
5301
5302 typedef struct _TAPE_ERASE {
5303   ULONG Type;
5304   BOOLEAN Immediate;
5305 } TAPE_ERASE, *PTAPE_ERASE;
5306
5307 typedef struct _TAPE_GET_DRIVE_PARAMETERS {
5308   BOOLEAN ECC;
5309   BOOLEAN Compression;
5310   BOOLEAN DataPadding;
5311   BOOLEAN ReportSetmarks;
5312   ULONG DefaultBlockSize;
5313   ULONG MaximumBlockSize;
5314   ULONG MinimumBlockSize;
5315   ULONG MaximumPartitionCount;
5316   ULONG FeaturesLow;
5317   ULONG FeaturesHigh;
5318   ULONG EOTWarningZoneSize;
5319 } TAPE_GET_DRIVE_PARAMETERS, *PTAPE_GET_DRIVE_PARAMETERS;
5320
5321 typedef struct _TAPE_GET_MEDIA_PARAMETERS {
5322   LARGE_INTEGER Capacity;
5323   LARGE_INTEGER Remaining;
5324   ULONG BlockSize;
5325   ULONG PartitionCount;
5326   BOOLEAN WriteProtected;
5327 } TAPE_GET_MEDIA_PARAMETERS, *PTAPE_GET_MEDIA_PARAMETERS;
5328
5329 typedef struct _TAPE_GET_POSITION {
5330   ULONG Type;
5331   ULONG Partition;
5332   LARGE_INTEGER Offset;
5333 } TAPE_GET_POSITION, *PTAPE_GET_POSITION;
5334
5335 typedef struct _TAPE_PREPARE {
5336   ULONG Operation;
5337   BOOLEAN Immediate;
5338 } TAPE_PREPARE, *PTAPE_PREPARE;
5339
5340 typedef struct _TAPE_SET_DRIVE_PARAMETERS {
5341   BOOLEAN ECC;
5342   BOOLEAN Compression;
5343   BOOLEAN DataPadding;
5344   BOOLEAN ReportSetmarks;
5345   ULONG EOTWarningZoneSize;
5346 } TAPE_SET_DRIVE_PARAMETERS, *PTAPE_SET_DRIVE_PARAMETERS;
5347
5348 typedef struct _TAPE_SET_MEDIA_PARAMETERS {
5349   ULONG BlockSize;
5350 } TAPE_SET_MEDIA_PARAMETERS, *PTAPE_SET_MEDIA_PARAMETERS;
5351
5352 typedef struct _TAPE_SET_POSITION {
5353   ULONG Method;
5354   ULONG Partition;
5355   LARGE_INTEGER Offset;
5356   BOOLEAN Immediate;
5357 } TAPE_SET_POSITION, *PTAPE_SET_POSITION;
5358
5359 typedef struct _TAPE_WRITE_MARKS {
5360   ULONG Type;
5361   ULONG Count;
5362   BOOLEAN Immediate;
5363 } TAPE_WRITE_MARKS, *PTAPE_WRITE_MARKS;
5364
5365 typedef struct {
5366   HINSTANCE hInst;
5367   UINT nID;
5368 } TBADDBITMAP, *LPTBADDBITMAP;
5369
5370 typedef struct _TBBUTTON {
5371   int iBitmap;
5372   int idCommand;
5373   BYTE fsState;
5374   BYTE fsStyle;
5375   DWORD dwData;
5376   int iString;
5377 } TBBUTTON,  * PTBBUTTON,  * LPTBBUTTON;
5378 typedef const TBBUTTON  * LPCTBBUTTON;
5379
5380 typedef struct {
5381   NMHDR    hdr;
5382   int      iItem;
5383   TBBUTTON tbButton;
5384   int      cchText;
5385   LPSTR    pszText;
5386 } TBNOTIFYA, *LPTBNOTIFYA;
5387
5388 typedef struct {
5389   NMHDR    hdr;
5390   int      iItem;
5391   TBBUTTON tbButton;
5392   int      cchText;
5393   LPWSTR   pszText;
5394 } TBNOTIFYW, *LPTBNOTIFYW;
5395
5396 typedef_tident(TBNOTIFY)
5397 typedef_tident(LPTBNOTIFY)
5398
5399 typedef struct {
5400   HKEY    hkr;
5401   LPCSTR  pszSubKey;
5402   LPCSTR  pszValueName;
5403 } TBSAVEPARAMSA;
5404
5405 typedef struct {
5406   HKEY    hkr;
5407   LPCWSTR pszSubKey;
5408   LPCWSTR pszValueName;
5409 } TBSAVEPARAMSW;
5410
5411 typedef_tident(TBSAVEPARAMS)
5412
5413 typedef struct _TC_HITTESTINFO {
5414   POINT pt;
5415   UINT  flags;
5416 } TC_HITTESTINFO;
5417
5418 typedef struct _TC_ITEMA {
5419   UINT   mask;
5420   UINT   lpReserved1;
5421   UINT   lpReserved2;
5422   LPSTR  pszText;
5423   int    cchTextMax;
5424   int    iImage;
5425   LPARAM lParam;
5426 } TC_ITEMA;
5427
5428 typedef struct _TC_ITEMW {
5429   UINT   mask;
5430   UINT   lpReserved1;
5431   UINT   lpReserved2;
5432   LPWSTR pszText;
5433   int    cchTextMax;
5434   int    iImage;
5435   LPARAM lParam;
5436 } TC_ITEMW;
5437
5438 typedef_tident(TC_ITEM)
5439
5440 typedef struct _TC_ITEMHEADERA {
5441   UINT   mask;
5442   UINT   lpReserved1;
5443   UINT   lpReserved2;
5444   LPSTR  pszText;
5445   int    cchTextMax;
5446   int    iImage;
5447 } TC_ITEMHEADERA;
5448
5449 typedef struct _TC_ITEMHEADERW {
5450   UINT   mask;
5451   UINT   lpReserved1;
5452   UINT   lpReserved2;
5453   LPWSTR pszText;
5454   int    cchTextMax;
5455   int    iImage;
5456 } TC_ITEMHEADERW;
5457
5458 typedef_tident(TC_ITEMHEADER)
5459
5460 typedef struct _TC_KEYDOWN {
5461   NMHDR hdr;
5462   WORD wVKey;
5463   UINT flags;
5464 } TC_KEYDOWN;
5465
5466 typedef struct _textrangeA {
5467   CHARRANGE chrg;
5468   LPSTR     lpstrText;
5469 } TEXTRANGEA;
5470
5471 typedef struct _textrangeW {
5472   CHARRANGE chrg;
5473   LPWSTR    lpstrText;
5474 } TEXTRANGEW;
5475
5476 typedef_tident(TEXTRANGE)
5477
5478 typedef struct tagTOGGLEKEYS {
5479   DWORD cbSize;
5480   DWORD dwFlags;
5481 } TOGGLEKEYS;
5482
5483 typedef struct {
5484   UINT      cbSize;
5485   UINT      uFlags;
5486   HWND      hwnd;
5487   UINT      uId;
5488   RECT      rect;
5489   HINSTANCE hinst;
5490   LPSTR     lpszText;
5491 } TOOLINFOA, *PTOOLINFOA, *LPTOOLINFOA;
5492
5493 typedef struct {
5494   UINT      cbSize;
5495   UINT      uFlags;
5496   HWND      hwnd;
5497   UINT      uId;
5498   RECT      rect;
5499   HINSTANCE hinst;
5500   LPWSTR    lpszText;
5501 } TOOLINFOW, *PTOOLINFOW, *LPTOOLINFOW;
5502
5503 typedef_tident(TOOLINFO)
5504 typedef_tident(PTOOLINFO)
5505 typedef_tident(LPTOOLINFO)
5506
5507 typedef struct {
5508   NMHDR     hdr;
5509   LPSTR     lpszText;
5510   CHAR      szText[80];
5511   HINSTANCE hinst;
5512   UINT      uFlags;
5513 } TOOLTIPTEXTA, *LPTOOLTIPTEXTA;
5514
5515 typedef struct {
5516   NMHDR     hdr;
5517   LPWSTR    lpszText;
5518   WCHAR     szText[80];
5519   HINSTANCE hinst;
5520   UINT      uFlags;
5521 } TOOLTIPTEXTW, *LPTOOLTIPTEXTW;
5522
5523 typedef_tident(TOOLTIPTEXT)
5524 typedef_tident(LPTOOLTIPTEXT)
5525
5526 typedef struct tagTPMPARAMS {
5527   UINT cbSize;
5528   RECT rcExclude;
5529 } TPMPARAMS,   *LPTPMPARAMS;
5530
5531 #if 0 /* RobD - typedef removed due to conflict with mingw headers */
5532 typedef struct _TRANSMIT_FILE_BUFFERS {
5533   PVOID Head;
5534   DWORD HeadLength;
5535   PVOID Tail;
5536   DWORD TailLength;
5537 } TRANSMIT_FILE_BUFFERS;
5538 #endif
5539
5540 typedef struct _TT_HITTESTINFOA {
5541   HWND      hwnd;
5542   POINT     pt;
5543   TOOLINFOA ti;
5544 } TTHITTESTINFOA, *LPHITTESTINFOA;
5545
5546 typedef struct _TT_HITTESTINFOW {
5547   HWND      hwnd;
5548   POINT     pt;
5549   TOOLINFOW ti;
5550 } TTHITTESTINFOW, *LPHITTESTINFOW;
5551
5552 typedef_tident(TTHITTESTINFO)
5553 typedef_tident(LPHITTESTINFO)
5554
5555 typedef struct tagTTPOLYCURVE {
5556   WORD    wType;
5557   WORD    cpfx;
5558   POINTFX apfx[1];
5559 } TTPOLYCURVE,  * LPTTPOLYCURVE;
5560
5561 typedef struct _TTPOLYGONHEADER {
5562   DWORD   cb;
5563   DWORD   dwType;
5564   POINTFX pfxStart;
5565 } TTPOLYGONHEADER, *PTTPOLYGONHEADER, *LPTTPOLYGONHEADER;
5566
5567 typedef struct _TV_DISPINFOA {
5568   NMHDR    hdr;
5569   TV_ITEMA item;
5570 } TV_DISPINFOA;
5571
5572 typedef struct _TV_DISPINFOW {
5573   NMHDR    hdr;
5574   TV_ITEMW item;
5575 } TV_DISPINFOW;
5576
5577 typedef_tident(TV_DISPINFO)
5578
5579 typedef struct _TVHITTESTINFO {
5580   POINT     pt;
5581   UINT      flags;
5582   HTREEITEM hItem;
5583 } TV_HITTESTINFO, *LPTV_HITTESTINFO;
5584
5585 typedef struct _TV_INSERTSTRUCTA {
5586   HTREEITEM hParent;
5587   HTREEITEM hInsertAfter;
5588   TV_ITEMA  item;
5589 } TV_INSERTSTRUCTA, *LPTV_INSERTSTRUCTA;
5590
5591 typedef struct _TV_INSERTSTRUCTW {
5592   HTREEITEM hParent;
5593   HTREEITEM hInsertAfter;
5594   TV_ITEMW  item;
5595 } TV_INSERTSTRUCTW, *LPTV_INSERTSTRUCTW;
5596
5597 typedef_tident(TV_INSERTSTRUCT)
5598 typedef_tident(LPTV_INSERTSTRUCT)
5599
5600 typedef struct _TV_KEYDOWN {
5601   NMHDR hdr;
5602   WORD  wVKey;
5603   UINT  flags;
5604 } TV_KEYDOWN;
5605
5606 typedef struct _TV_SORTCB {
5607   HTREEITEM    hParent;
5608   PFNTVCOMPARE lpfnCompare;
5609   LPARAM       lParam;
5610 } TV_SORTCB,   *LPTV_SORTCB;
5611
5612 typedef struct {
5613   UINT nSec;
5614   UINT nInc;
5615 } UDACCEL;
5616
5617 typedef struct _UNIVERSAL_NAME_INFOA {
5618   LPSTR   lpUniversalName;
5619 } UNIVERSAL_NAME_INFOA;
5620
5621 typedef struct _UNIVERSAL_NAME_INFOW {
5622   LPWSTR  lpUniversalName;
5623 } UNIVERSAL_NAME_INFOW;
5624
5625 typedef_tident(UNIVERSAL_NAME_INFO)
5626
5627 typedef struct tagUSEROBJECTFLAGS {
5628   WINBOOL fInherit;
5629   WINBOOL fReserved;
5630   DWORD dwFlags;
5631 } USEROBJECTFLAGS;
5632
5633 typedef struct _VERIFY_INFORMATION {
5634   LARGE_INTEGER  StartingOffset;
5635   DWORD  Length;
5636 } VERIFY_INFORMATION ;
5637
5638 typedef struct _VS_FIXEDFILEINFO {
5639   DWORD dwSignature;
5640   DWORD dwStrucVersion;
5641   DWORD dwFileVersionMS;
5642   DWORD dwFileVersionLS;
5643   DWORD dwProductVersionMS;
5644   DWORD dwProductVersionLS;
5645   DWORD dwFileFlagsMask;
5646   DWORD dwFileFlags;
5647   DWORD dwFileOS;
5648   DWORD dwFileType;
5649   DWORD dwFileSubtype;
5650   DWORD dwFileDateMS;
5651   DWORD dwFileDateLS;
5652 } VS_FIXEDFILEINFO;
5653
5654 typedef struct _WIN32_FIND_DATAA {
5655   DWORD    dwFileAttributes;
5656   FILETIME ftCreationTime;
5657   FILETIME ftLastAccessTime;
5658   FILETIME ftLastWriteTime;
5659   DWORD    nFileSizeHigh;
5660   DWORD    nFileSizeLow;
5661   DWORD    dwReserved0;
5662   DWORD    dwReserved1;
5663   CHAR     cFileName[ MAX_PATH ];
5664   CHAR     cAlternateFileName[ 14 ];
5665 } WIN32_FIND_DATAA, *LPWIN32_FIND_DATAA, *PWIN32_FIND_DATAA;
5666
5667 typedef struct _WIN32_FIND_DATAW {
5668   DWORD dwFileAttributes;
5669   FILETIME ftCreationTime;
5670   FILETIME ftLastAccessTime;
5671   FILETIME ftLastWriteTime;
5672   DWORD    nFileSizeHigh;
5673   DWORD    nFileSizeLow;
5674   DWORD    dwReserved0;
5675   DWORD    dwReserved1;
5676   WCHAR    cFileName[ MAX_PATH ];
5677   WCHAR    cAlternateFileName[ 14 ];
5678 } WIN32_FIND_DATAW, *LPWIN32_FIND_DATAW, *PWIN32_FIND_DATAW;
5679
5680 typedef_tident(WIN32_FIND_DATA)
5681 typedef_tident(PWIN32_FIND_DATA)
5682 typedef_tident(LPWIN32_FIND_DATA)
5683
5684 typedef struct _WIN32_STREAM_ID {
5685   DWORD dwStreamId;
5686   DWORD dwStreamAttributes;
5687   LARGE_INTEGER Size;
5688   DWORD dwStreamNameSize;
5689   WCHAR *cStreamName;
5690 } WIN32_STREAM_ID;
5691
5692 typedef struct _WINDOWPLACEMENT {
5693   UINT  length;
5694   UINT  flags;
5695   UINT  showCmd;
5696   POINT ptMinPosition;
5697   POINT ptMaxPosition;
5698   RECT  rcNormalPosition;
5699 } WINDOWPLACEMENT;
5700
5701 typedef struct _WNDCLASSA {
5702   UINT    style;
5703   WNDPROC lpfnWndProc;
5704   int     cbClsExtra;
5705   int     cbWndExtra;
5706   HANDLE  hInstance;
5707   HICON   hIcon;
5708   HCURSOR hCursor;
5709   HBRUSH  hbrBackground;
5710   LPCSTR  lpszMenuName;
5711   LPCSTR  lpszClassName;
5712 } WNDCLASSA, *LPWNDCLASSA;
5713
5714 typedef struct _WNDCLASSW {
5715   UINT    style;
5716   WNDPROC lpfnWndProc;
5717   int     cbClsExtra;
5718   int     cbWndExtra;
5719   HANDLE  hInstance;
5720   HICON   hIcon;
5721   HCURSOR hCursor;
5722   HBRUSH  hbrBackground;
5723   LPCWSTR lpszMenuName;
5724   LPCWSTR lpszClassName;
5725 } WNDCLASSW, *LPWNDCLASSW;
5726
5727 typedef_tident(WNDCLASS)
5728
5729 typedef struct _WNDCLASSEXA {
5730   UINT    cbSize;
5731   UINT    style;
5732   WNDPROC lpfnWndProc;
5733   int     cbClsExtra;
5734   int     cbWndExtra;
5735   HANDLE  hInstance;
5736   HICON   hIcon;
5737   HCURSOR hCursor;
5738   HBRUSH  hbrBackground;
5739   LPCSTR  lpszMenuName;
5740   LPCSTR  lpszClassName;
5741   HICON   hIconSm;
5742 } WNDCLASSEXA, *LPWNDCLASSEXA;
5743
5744 typedef struct _WNDCLASSEXW {
5745   UINT    cbSize;
5746   UINT    style;
5747   WNDPROC lpfnWndProc;
5748   int     cbClsExtra;
5749   int     cbWndExtra;
5750   HANDLE  hInstance;
5751   HICON   hIcon;
5752   HCURSOR hCursor;
5753   HBRUSH  hbrBackground;
5754   LPCWSTR lpszMenuName;
5755   LPCWSTR lpszClassName;
5756   HICON   hIconSm;
5757 } WNDCLASSEXW, *LPWNDCLASSEXW;
5758
5759 typedef_tident(WNDCLASSEX)
5760
5761 typedef struct _CONNECTDLGSTRUCTA {
5762   DWORD          cbStructure;
5763   HWND           hwndOwner;
5764   LPNETRESOURCEA lpConnRes;
5765   DWORD          dwFlags;
5766   DWORD          dwDevNum;
5767 } CONNECTDLGSTRUCTA, *LPCONNECTDLGSTRUCTA;
5768
5769 typedef struct _CONNECTDLGSTRUCTW {
5770   DWORD          cbStructure;
5771   HWND           hwndOwner;
5772   LPNETRESOURCEW lpConnRes;
5773   DWORD          dwFlags;
5774   DWORD          dwDevNum;
5775 } CONNECTDLGSTRUCTW, *LPCONNECTDLGSTRUCTW;
5776
5777 typedef_tident(CONNECTDLGSTRUCT)
5778 typedef_tident(LPCONNECTDLGSTRUCT)
5779
5780 typedef struct _DISCDLGSTRUCTA {
5781   DWORD           cbStructure;
5782   HWND            hwndOwner;
5783   LPSTR           lpLocalName;
5784   LPSTR           lpRemoteName;
5785   DWORD           dwFlags;
5786 } DISCDLGSTRUCTA, *LPDISCDLGSTRUCTA;
5787
5788 typedef struct _DISCDLGSTRUCTW {
5789   DWORD           cbStructure;
5790   HWND            hwndOwner;
5791   LPWSTR          lpLocalName;
5792   LPWSTR          lpRemoteName;
5793   DWORD           dwFlags;
5794 } DISCDLGSTRUCTW, *LPDISCDLGSTRUCTW;
5795
5796 typedef_tident(DISCDLGSTRUCT)
5797 typedef_tident(LPDISCDLGSTRUCT)
5798
5799 typedef struct _NETINFOSTRUCT{
5800     DWORD cbStructure;
5801     DWORD dwProviderVersion;
5802     DWORD dwStatus;
5803     DWORD dwCharacteristics;
5804     DWORD dwHandle;
5805     WORD  wNetType;
5806     DWORD dwPrinters;
5807     DWORD dwDrives;
5808 } NETINFOSTRUCT, *LPNETINFOSTRUCT;
5809
5810 typedef struct _NETCONNECTINFOSTRUCT{
5811   DWORD cbStructure;
5812   DWORD dwFlags;
5813   DWORD dwSpeed;
5814   DWORD dwDelay;
5815   DWORD dwOptDataSize;
5816 } NETCONNECTINFOSTRUCT, *LPNETCONNECTINFOSTRUCT;
5817
5818 typedef int (CALLBACK *ENUMMETAFILEPROC) (HDC, HANDLETABLE,
5819                                           METARECORD, int, LPARAM);
5820 typedef int (CALLBACK *ENHMETAFILEPROC) (HDC, HANDLETABLE,
5821                                          ENHMETARECORD, int, LPARAM);
5822
5823 typedef int (CALLBACK *ENUMFONTSPROCA) (LPLOGFONTA, LPTEXTMETRICA, DWORD, LPARAM);
5824 typedef int (CALLBACK *ENUMFONTSPROCW) (LPLOGFONTW, LPTEXTMETRICW, DWORD, LPARAM);
5825 typedef_tident(ENUMFONTSPROC)
5826 typedef int (CALLBACK *FONTENUMPROCA) (ENUMLOGFONTA *, NEWTEXTMETRICA *,
5827                                        int, LPARAM);
5828 typedef int (CALLBACK *FONTENUMPROCW) (ENUMLOGFONTW *, NEWTEXTMETRICW *,
5829                                        int, LPARAM);
5830 typedef_tident(FONTENUMPROC)
5831 typedef int (CALLBACK *FONTENUMEXPROCA) (ENUMLOGFONTEXA *, NEWTEXTMETRICEXA *,
5832                                          int, LPARAM);
5833 typedef int (CALLBACK *FONTENUMEXPROCW) (ENUMLOGFONTEXW *, NEWTEXTMETRICEXW *,
5834                                          int, LPARAM);
5835 typedef_tident(FONTENUMEXPROC)
5836
5837 typedef VOID (CALLBACK *LPOVERLAPPED_COMPLETION_ROUTINE) (DWORD, DWORD,
5838                                                           LPOVERLAPPED);
5839
5840 /*
5841   Structures for the extensions to OpenGL
5842   */
5843 typedef struct _POINTFLOAT
5844 {
5845   FLOAT   x;
5846   FLOAT   y;
5847 } POINTFLOAT, *PPOINTFLOAT;
5848
5849 typedef struct _GLYPHMETRICSFLOAT
5850 {
5851   FLOAT       gmfBlackBoxX;
5852   FLOAT       gmfBlackBoxY;
5853   POINTFLOAT  gmfptGlyphOrigin;
5854   FLOAT       gmfCellIncX;
5855   FLOAT       gmfCellIncY;
5856 } GLYPHMETRICSFLOAT, *PGLYPHMETRICSFLOAT, *LPGLYPHMETRICSFLOAT;
5857
5858 typedef struct tagLAYERPLANEDESCRIPTOR
5859 {
5860   WORD  nSize;
5861   WORD  nVersion;
5862   DWORD dwFlags;
5863   BYTE  iPixelType;
5864   BYTE  cColorBits;
5865   BYTE  cRedBits;
5866   BYTE  cRedShift;
5867   BYTE  cGreenBits;
5868   BYTE  cGreenShift;
5869   BYTE  cBlueBits;
5870   BYTE  cBlueShift;
5871   BYTE  cAlphaBits;
5872   BYTE  cAlphaShift;
5873   BYTE  cAccumBits;
5874   BYTE  cAccumRedBits;
5875   BYTE  cAccumGreenBits;
5876   BYTE  cAccumBlueBits;
5877   BYTE  cAccumAlphaBits;
5878   BYTE  cDepthBits;
5879   BYTE  cStencilBits;
5880   BYTE  cAuxBuffers;
5881   BYTE  iLayerPlane;
5882   BYTE  bReserved;
5883   COLORREF crTransparent;
5884 } LAYERPLANEDESCRIPTOR, *PLAYERPLANEDESCRIPTOR, *LPLAYERPLANEDESCRIPTOR;
5885
5886 typedef struct tagPIXELFORMATDESCRIPTOR
5887 {
5888   WORD  nSize;
5889   WORD  nVersion;
5890   DWORD dwFlags;
5891   BYTE  iPixelType;
5892   BYTE  cColorBits;
5893   BYTE  cRedBits;
5894   BYTE  cRedShift;
5895   BYTE  cGreenBits;
5896   BYTE  cGreenShift;
5897   BYTE  cBlueBits;
5898   BYTE  cBlueShift;
5899   BYTE  cAlphaBits;
5900   BYTE  cAlphaShift;
5901   BYTE  cAccumBits;
5902   BYTE  cAccumRedBits;
5903   BYTE  cAccumGreenBits;
5904   BYTE  cAccumBlueBits;
5905   BYTE  cAccumAlphaBits;
5906   BYTE  cDepthBits;
5907   BYTE  cStencilBits;
5908   BYTE  cAuxBuffers;
5909   BYTE  iLayerType;
5910   BYTE  bReserved;
5911   DWORD dwLayerMask;
5912   DWORD dwVisibleMask;
5913   DWORD dwDamageMask;
5914 } PIXELFORMATDESCRIPTOR, *PPIXELFORMATDESCRIPTOR, *LPPIXELFORMATDESCRIPTOR;
5915
5916 typedef struct
5917 {
5918   LPWSTR    usri2_name;
5919   LPWSTR    usri2_password;
5920   DWORD     usri2_password_age;
5921   DWORD     usri2_priv;
5922   LPWSTR    usri2_home_dir;
5923   LPWSTR    usri2_comment;
5924   DWORD     usri2_flags;
5925   LPWSTR    usri2_script_path;
5926   DWORD     usri2_auth_flags;
5927   LPWSTR    usri2_full_name;
5928   LPWSTR    usri2_usr_comment;
5929   LPWSTR    usri2_parms;
5930   LPWSTR    usri2_workstations;
5931   DWORD     usri2_last_logon;
5932   DWORD     usri2_last_logoff;
5933   DWORD     usri2_acct_expires;
5934   DWORD     usri2_max_storage;
5935   DWORD     usri2_units_per_week;
5936   PBYTE     usri2_logon_hours;
5937   DWORD     usri2_bad_pw_count;
5938   DWORD     usri2_num_logons;
5939   LPWSTR    usri2_logon_server;
5940   DWORD     usri2_country_code;
5941   DWORD     usri2_code_page;
5942 } USER_INFO_2, *PUSER_INFO_2, *LPUSER_INFO_2;
5943
5944 typedef struct
5945 {
5946   LPWSTR    usri0_name;
5947 } USER_INFO_0, *PUSER_INFO_0, *LPUSER_INFO_0;
5948
5949 typedef struct
5950 {
5951   LPWSTR    usri3_name;
5952   LPWSTR    usri3_password;
5953   DWORD     usri3_password_age;
5954   DWORD     usri3_priv;
5955   LPWSTR    usri3_home_dir;
5956   LPWSTR    usri3_comment;
5957   DWORD     usri3_flags;
5958   LPWSTR    usri3_script_path;
5959   DWORD     usri3_auth_flags;
5960   LPWSTR    usri3_full_name;
5961   LPWSTR    usri3_usr_comment;
5962   LPWSTR    usri3_parms;
5963   LPWSTR    usri3_workstations;
5964   DWORD     usri3_last_logon;
5965   DWORD     usri3_last_logoff;
5966   DWORD     usri3_acct_expires;
5967   DWORD     usri3_max_storage;
5968   DWORD     usri3_units_per_week;
5969   PBYTE     usri3_logon_hours;
5970   DWORD     usri3_bad_pw_count;
5971   DWORD     usri3_num_logons;
5972   LPWSTR    usri3_logon_server;
5973   DWORD     usri3_country_code;
5974   DWORD     usri3_code_page;
5975   DWORD     usri3_user_id;
5976   DWORD     usri3_primary_group_id;
5977   LPWSTR    usri3_profile;
5978   LPWSTR    usri3_home_dir_drive;
5979   DWORD     usri3_password_expired;
5980 } USER_INFO_3, *PUSER_INFO_3, *LPUSER_INFO_3;
5981
5982 typedef struct
5983 {
5984   LPWSTR   grpi2_name;
5985   LPWSTR   grpi2_comment;
5986   DWORD    grpi2_group_id;
5987   DWORD    grpi2_attributes;
5988 } GROUP_INFO_2, *PGROUP_INFO_2;
5989
5990 typedef struct
5991 {
5992   LPWSTR   lgrpi0_name;
5993 } LOCALGROUP_INFO_0, *PLOCALGROUP_INFO_0, *LPLOCALGROUP_INFO_0;
5994
5995 /* PE executable header.  */
5996 /* Windows.h now includes pe.h to avoid conflicts! */
5997
5998 typedef struct _DISPLAY_DEVICE {
5999   DWORD cb;
6000   WCHAR DeviceName[32];
6001   WCHAR DeviceString[128];
6002   DWORD StateFlags;
6003   WCHAR DeviceID[128];
6004   WCHAR DeviceKey[128];
6005 } DISPLAY_DEVICE, *PDISPLAY_DEVICE;
6006
6007 typedef HANDLE HMONITOR;
6008 typedef HANDLE HDEVNOTIFY;
6009
6010 typedef BOOL (CALLBACK *MonitorEnumProc)(
6011   HMONITOR hMonitor,
6012   HDC hdcMonitor,
6013   LPRECT lprcMonitor,
6014   LPARAM dwData);
6015
6016 typedef MonitorEnumProc MONITORENUMPROC;
6017
6018 typedef struct {
6019   UINT  cbSize;
6020   HWND  hwnd;
6021   DWORD dwFlags;
6022   UINT  uCount;
6023   DWORD dwTimeout;
6024 } FLASHWINFO, *PFLASHWINFO;
6025
6026 typedef struct tagALTTABINFO {
6027   DWORD cbSize;
6028   int   cItems;
6029   int   cColumns;
6030   int   cRows;
6031   int   iColFocus;
6032   int   iRowFocus;
6033   int   cxItem;
6034   int   cyItem;
6035   POINT ptStart;
6036 } ALTTABINFO, *PALTTABINFO, *LPALTTABINFO;
6037
6038 typedef struct tagCOMBOBOXINFO {
6039   DWORD cbSize;
6040   RECT  rcItem;
6041   RECT  rcButton;
6042   DWORD stateButton;
6043   HWND  hwndCombo;
6044   HWND  hwndItem;
6045   HWND  hwndList;
6046 } COMBOBOXINFO, *PCOMBOBOXINFO, *LPCOMBOBOXINFO;
6047
6048 typedef struct tagCURSORINFO {
6049   DWORD   cbSize;
6050   DWORD   flags;
6051   HCURSOR hCursor;
6052   POINT   ptScreenPos;
6053 } CURSORINFO, *PCURSORINFO, *LPCURSORINFO;
6054
6055 typedef struct tagGUITHREADINFO {
6056   DWORD   cbSize;
6057   DWORD   flags;
6058   HWND    hwndActive;
6059   HWND    hwndFocus;
6060   HWND    hwndCapture;
6061   HWND    hwndMenuOwner;
6062   HWND    hwndMoveSize;
6063   HWND    hwndCaret;
6064   RECT    rcCaret;
6065 } GUITHREADINFO, *PGUITHREADINFO, *LPGUITHREADINFO;
6066
6067 typedef struct tagLASTINPUTINFO {
6068   UINT cbSize;
6069   DWORD dwTime;
6070 } LASTINPUTINFO, *PLASTINPUTINFO;
6071
6072 typedef struct tagMENUBARINFO {
6073   DWORD cbSize;
6074   RECT  rcBar;
6075   HMENU hMenu;
6076   HWND  hwndMenu;
6077   BOOL  fBarFocused:1;
6078   BOOL  fFocused:1;
6079 } MENUBARINFO, *PMENUBARINFO;
6080
6081 typedef struct tagMENUINFO {
6082   DWORD   cbSize;
6083   DWORD   fMask;
6084   DWORD   dwStyle;
6085   UINT    cyMax;
6086   HBRUSH  hbrBack;
6087   DWORD   dwContextHelpID;
6088   ULONG_PTR  dwMenuData;
6089 } MENUINFO, FAR *LPMENUINFO;
6090 typedef MENUINFO CONST FAR *LPCMENUINFO;
6091
6092 typedef struct tagMONITORINFO {
6093   DWORD cbSize;
6094   RECT rcMonitor;
6095   RECT rcWork;
6096   DWORD dwFlags;
6097 } MONITORINFO, *LPMONITORINFO;
6098
6099 typedef struct tagMOUSEMOVEPOINT {
6100   int       x;
6101   int       y;
6102   DWORD     time;
6103   ULONG_PTR dwExtraInfo;
6104 } MOUSEMOVEPOINT, *PMOUSEMOVEPOINT, *LPMOUSEMOVEPOINT;
6105
6106 #define CCHILDREN_SCROLLBAR 5
6107
6108 typedef struct tagSCROLLBARINFO {
6109   DWORD cbSize;
6110   RECT  rcScrollBar;
6111   int   dxyLineButton;
6112   int   xyThumbTop;
6113   int   xyThumbBottom;
6114   int   reserved;
6115   DWORD rgstate[CCHILDREN_SCROLLBAR+1];
6116 } SCROLLBARINFO, *PSCROLLBARINFO, *LPSCROLLBARINFO;
6117
6118 #define CCHILDREN_TITLEBAR 5
6119
6120 typedef struct tagTITLEBARINFO {
6121   DWORD cbSize;
6122   RECT  rcTitleBar;
6123   DWORD rgstate[CCHILDREN_TITLEBAR+1];
6124 } TITLEBARINFO, *PTITLEBARINFO, *LPTITLEBARINFO;
6125
6126 typedef struct tagWINDOWINFO {
6127   DWORD   cbSize;
6128   RECT    rcWindow;
6129   RECT    rcClient;
6130   DWORD   dwStyle;
6131   DWORD   dwExStyle;
6132   DWORD   dwWindowStatus;
6133   UINT    cxWindowBorders;
6134   UINT    cyWindowBorders;
6135   ATOM    atomWindowType;
6136   WORD    wCreatorVersion;
6137 } WINDOWINFO, *PWINDOWINFO, *LPWINDOWINFO;
6138
6139 typedef struct tagMOUSEINPUT {
6140   LONG    dx;
6141   LONG    dy;
6142   DWORD   mouseData;
6143   DWORD   dwFlags;
6144   DWORD   time;
6145   ULONG_PTR   dwExtraInfo;
6146 } MOUSEINPUT, *PMOUSEINPUT;
6147
6148 typedef struct tagKEYBDINPUT {
6149   WORD      wVk;
6150   WORD      wScan;
6151   DWORD     dwFlags;
6152   DWORD     time;
6153   ULONG_PTR dwExtraInfo;
6154 } KEYBDINPUT, *PKEYBDINPUT;
6155
6156 typedef struct tagHARDWAREINPUT {
6157   DWORD   uMsg;
6158   WORD    wParamL;
6159   WORD    wParamH;
6160 } HARDWAREINPUT, *PHARDWAREINPUT;
6161
6162 typedef struct tagINPUT {
6163   DWORD type;
6164   union
6165   {
6166     MOUSEINPUT mi;
6167     KEYBDINPUT ki;
6168     HARDWAREINPUT hi;
6169   } u;
6170 } INPUT, *PINPUT, FAR* LPINPUT;
6171
6172 typedef struct tagTRACKMOUSEEVENT {
6173   DWORD cbSize;
6174   DWORD dwFlags;
6175   HWND  hwndTrack;
6176   DWORD dwHoverTime;
6177 } TRACKMOUSEEVENT, *LPTRACKMOUSEEVENT;
6178
6179 typedef IMAGE_THUNK_DATA *          PImgThunkData;
6180 typedef const IMAGE_THUNK_DATA *    PCImgThunkData;
6181
6182 typedef struct ImgDelayDescr {
6183     DWORD           grAttrs;
6184     LPCSTR          szName;
6185     HMODULE *       phmod;
6186     PImgThunkData   pIAT;
6187     PCImgThunkData  pINT;
6188     PCImgThunkData  pBoundIAT;
6189     PCImgThunkData  pUnloadIAT;
6190     DWORD           dwTimeStamp;
6191     } ImgDelayDescr, * PImgDelayDescr;
6192
6193 typedef const ImgDelayDescr *   PCImgDelayDescr;
6194
6195 typedef struct DelayLoadProc {
6196     BOOL                fImportByName;
6197     union {
6198         LPCSTR          szProcName;
6199         DWORD           dwOrdinal;
6200         };
6201     } DelayLoadProc;
6202
6203 typedef struct DelayLoadInfo {
6204     DWORD               cb;
6205     PCImgDelayDescr     pidd;
6206     FARPROC *           ppfn;
6207     LPCSTR              szDll;
6208     DelayLoadProc       dlp;
6209     HMODULE             hmodCur;
6210     FARPROC             pfnCur;
6211     DWORD               dwLastError;
6212     } DelayLoadInfo, * PDelayLoadInfo;
6213
6214 typedef struct _RTL_HEAP_TAG_INFO {
6215         ULONG AllocCount;
6216         ULONG FreeCount;
6217         ULONG MemoryUsed;
6218 } RTL_HEAP_TAG_INFO, *LPRTL_HEAP_TAG_INFO, *PRTL_HEAP_TAG_INFO;
6219
6220 typedef struct _PORT_MESSAGE {
6221         USHORT DataSize;
6222         USHORT MessageSize;
6223         USHORT MessageType;
6224         USHORT VirtualRangesOffset;
6225         CLIENT_ID ClientId;
6226         ULONG MessageId;
6227         ULONG SectionSize;
6228 //      UCHAR Data [];
6229 } PORT_MESSAGE,*PPORT_MESSAGE;
6230
6231 typedef struct _PORT_SECTION_WRITE {
6232         ULONG Length;
6233         HANDLE SectionHandle;
6234         ULONG SectionOffset;
6235         ULONG ViewSize;
6236         PVOID ViewBase;
6237         PVOID TargetViewBase;
6238 } PORT_SECTION_WRITE,*PPORT_SECTION_WRITE;
6239
6240 typedef struct _PORT_SECTION_READ {
6241         ULONG Length;
6242         ULONG ViewSize;
6243         ULONG ViewBase;
6244 } PORT_SECTION_READ,*PPORT_SECTION_READ;
6245
6246 typedef struct _FILE_QUOTA_LIST_INFORMATION {
6247         ULONG NextEntryOffset;
6248         ULONG SidLength;
6249         SID Sid [1 ];
6250 } FILE_QUOTA_LIST_INFORMATION,*PFILE_QUOTA_LIST_INFORMATION;
6251
6252 typedef struct _BLENDFUNCTION {
6253   BYTE     BlendOp;
6254   BYTE     BlendFlags;
6255   BYTE     SourceConstantAlpha;
6256   BYTE     AlphaFormat;
6257 }BLENDFUNCTION, *PBLENDFUNCTION, *LPBLENDFUNCTION;
6258
6259 typedef enum _GET_FILEEX_INFO_LEVELS {
6260     GetFileExInfoStandard
6261 } GET_FILEEX_INFO_LEVELS;
6262
6263 typedef struct _WIN32_FILE_ATTRIBUTES_DATA {
6264     DWORD    dwFileAttributes;
6265     FILETIME ftCreationTime;
6266     FILETIME ftLastAccessTime;
6267     FILETIME ftLastWriteTime;
6268     DWORD    nFileSizeHigh;
6269     DWORD    nFileSizeLow;
6270 } WIN32_FILE_ATTRIBUTE_DATA, *LPWIN32_FILE_ATTRIBUTE_DATA;
6271
6272 typedef struct _GRADIENT_TRIANGLE {
6273   ULONG Vertex1;
6274   ULONG Vertex2;
6275   ULONG Vertex3;
6276 } GRADIENT_TRIANGLE, *PGRADIENT_TRIANGLE, *LPGRADIENT_TRIANGLE;
6277
6278 typedef struct _GRADIENT_RECT {
6279   ULONG UpperLeft;
6280   ULONG LowerRight;
6281 } GRADIENT_RECT, *PGRADIENT_RECT, *LPGRADIENT_RECT;
6282
6283 #ifdef __cplusplus
6284 }
6285 #endif /* __cplusplus */
6286
6287 #endif /* WIN32_LEAN_AND_MEAN */
6288
6289 #endif /* _GNU_H_WINDOWS32_STRUCTURES */