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