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 /* http://www.experts-exchange.com/Programming/Programming_Platforms/Win_Prog/Q_10010678.html
4299  *
4300  * IOCTL_DISK_MEDIA_REMOVAL disables the mechanism
4301  * on a SCSI device that ejects media. This function
4302  * may or may not be supported on SCSI devices that
4303  * support removable media.
4304  *
4305  * TRUE means prevent media from being removed.
4306  * FALSE means allow media removal.
4307  */
4308 typedef struct _PREVENT_MEDIA_REMOVAL {
4309   BOOLEAN PreventMediaRemoval;
4310 } PREVENT_MEDIA_REMOVAL ;
4311
4312 typedef struct tagPDA {
4313   DWORD     lStructSize;
4314   HWND      hwndOwner;
4315   HANDLE    hDevMode;
4316   HANDLE    hDevNames;
4317   HDC       hDC;
4318   DWORD     Flags;
4319   WORD      nFromPage;
4320   WORD      nToPage;
4321   WORD      nMinPage;
4322   WORD      nMaxPage;
4323   WORD      nCopies;
4324   HINSTANCE hInstance;
4325   DWORD     lCustData;
4326   LPPRINTHOOKPROC lpfnPrintHook;
4327   LPSETUPHOOKPROC lpfnSetupHook;
4328   LPCSTR    lpPrintTemplateName;
4329   LPCSTR    lpSetupTemplateName;
4330   HANDLE    hPrintTemplate;
4331   HANDLE    hSetupTemplate;
4332 } PACKED PRINTDLGA, *LPPRINTDLGA;
4333
4334 typedef struct tagPDW {
4335   DWORD     lStructSize;
4336   HWND      hwndOwner;
4337   HANDLE    hDevMode;
4338   HANDLE    hDevNames;
4339   HDC       hDC;
4340   DWORD     Flags;
4341   WORD      nFromPage;
4342   WORD      nToPage;
4343   WORD      nMinPage;
4344   WORD      nMaxPage;
4345   WORD      nCopies;
4346   HINSTANCE hInstance;
4347   DWORD     lCustData;
4348   LPPRINTHOOKPROC lpfnPrintHook;
4349   LPSETUPHOOKPROC lpfnSetupHook;
4350   LPCWSTR   lpPrintTemplateName;
4351   LPCWSTR   lpSetupTemplateName;
4352   HANDLE    hPrintTemplate;
4353   HANDLE    hSetupTemplate;
4354 } PACKED PRINTDLGW, *LPPRINTDLGW;
4355
4356 typedef_tident(PRINTDLG)
4357 typedef_tident(LPPRINTDLG)
4358
4359 typedef struct _PRINTER_DEFAULTSA
4360 {
4361   LPSTR       pDatatype;
4362   LPDEVMODEA  pDevMode;
4363   ACCESS_MASK DesiredAccess;
4364 } PRINTER_DEFAULTSA, *PPRINTER_DEFAULTSA, *LPPRINTER_DEFAULTSA;
4365
4366 typedef struct _PRINTER_DEFAULTSW
4367 {
4368   LPWSTR      pDatatype;
4369   LPDEVMODEW  pDevMode;
4370   ACCESS_MASK DesiredAccess;
4371 } PRINTER_DEFAULTSW, *PPRINTER_DEFAULTSW, *LPPRINTER_DEFAULTSW;
4372
4373 typedef_tident(PRINTER_DEFAULTS)
4374 typedef_tident(PPRINTER_DEFAULTS)
4375 typedef_tident(LPPRINTER_DEFAULTS)
4376
4377 typedef struct _PRINTER_INFO_1A {
4378   DWORD  Flags;
4379   LPSTR  pDescription;
4380   LPSTR  pName;
4381   LPSTR  pComment;
4382 } PRINTER_INFO_1A, *PPRINTER_INFO_1A, *LPPRINTER_INFO_1A;
4383
4384 typedef struct _PRINTER_INFO_1W {
4385   DWORD  Flags;
4386   LPWSTR pDescription;
4387   LPWSTR pName;
4388   LPWSTR pComment;
4389 } PRINTER_INFO_1W, *PPRINTER_INFO_1W, *LPPRINTER_INFO_1W;
4390
4391 typedef_tident(PRINTER_INFO_1)
4392 typedef_tident(PPRINTER_INFO_1)
4393 typedef_tident(LPPRINTER_INFO_1)
4394
4395 #if 0
4396 typedef struct _PRINTER_INFO_2A {
4397   LPSTR      pServerName;
4398   LPSTR      pPrinterName;
4399   LPSTR      pShareName;
4400   LPSTR      pPortName;
4401   LPSTR      pDriverName;
4402   LPSTR      pComment;
4403   LPSTR      pLocation;
4404   LPDEVMODEA pDevMode;
4405   LPSTR      pSepFile;
4406   LPSTR      pPrintProcessor;
4407   LPSTR      pDatatype;
4408   LPSTR      pParameters;
4409   PSECURITY_DESCRIPTOR pSecurityDescriptor;
4410   DWORD      Attributes;
4411   DWORD      Priority;
4412   DWORD      DefaultPriority;
4413   DWORD      StartTime;
4414   DWORD      UntilTime;
4415   DWORD      Status;
4416   DWORD      cJobs;
4417   DWORD      AveragePPM;
4418 } PRINTER_INFO_2A;
4419
4420 typedef struct _PRINTER_INFO_2W {
4421   LPWSTR     pServerName;
4422   LPWSTR     pPrinterName;
4423   LPWSTR     pShareName;
4424   LPWSTR     pPortName;
4425   LPWSTR     pDriverName;
4426   LPWSTR     pComment;
4427   LPWSTR     pLocation;
4428   LPDEVMODEW pDevMode;
4429   LPWSTR     pSepFile;
4430   LPWSTR     pPrintProcessor;
4431   LPWSTR     pDatatype;
4432   LPWSTR     pParameters;
4433   PSECURITY_DESCRIPTOR pSecurityDescriptor;
4434   DWORD      Attributes;
4435   DWORD      Priority;
4436   DWORD      DefaultPriority;
4437   DWORD      StartTime;
4438   DWORD      UntilTime;
4439   DWORD      Status;
4440   DWORD      cJobs;
4441   DWORD      AveragePPM;
4442 } PRINTER_INFO_2W;
4443
4444 typedef_tident(PRINTER_INFO_2)
4445
4446 typedef struct _PRINTER_INFO_3 {
4447   PSECURITY_DESCRIPTOR pSecurityDescriptor;
4448 } PRINTER_INFO_3;
4449 #endif
4450
4451 typedef struct _PRINTER_INFO_4A {
4452   LPSTR  pPrinterName;
4453   LPSTR  pServerName;
4454   DWORD  Attributes;
4455 } PRINTER_INFO_4A;
4456
4457 typedef struct _PRINTER_INFO_4W {
4458   LPWSTR pPrinterName;
4459   LPWSTR pServerName;
4460   DWORD  Attributes;
4461 } PRINTER_INFO_4W;
4462
4463 typedef_tident(PRINTER_INFO_4)
4464
4465 typedef struct _PRINTER_INFO_5A {
4466   LPSTR     pPrinterName;
4467   LPSTR     pPortName;
4468   DWORD     Attributes;
4469   DWORD     DeviceNotSelectedTimeout;
4470   DWORD     TransmissionRetryTimeout;
4471 } PRINTER_INFO_5A;
4472
4473 typedef struct _PRINTER_INFO_5W {
4474   LPWSTR    pPrinterName;
4475   LPWSTR    pPortName;
4476   DWORD     Attributes;
4477   DWORD     DeviceNotSelectedTimeout;
4478   DWORD     TransmissionRetryTimeout;
4479 } PRINTER_INFO_5W;
4480
4481 typedef_tident(PRINTER_INFO_5)
4482
4483 typedef struct _PRINTER_NOTIFY_INFO_DATA {
4484   WORD   Type;
4485   WORD   Field;
4486   DWORD  Reserved;
4487   DWORD  Id;
4488   union {
4489     DWORD  adwData[2];
4490     struct {
4491       DWORD  cbBuf;
4492       LPVOID pBuf;
4493     } Data;
4494   } NotifyData;
4495 } PRINTER_NOTIFY_INFO_DATA;
4496
4497 typedef struct _PRINTER_NOTIFY_INFO {
4498   DWORD  Version;
4499   DWORD  Flags;
4500   DWORD  Count;
4501   PRINTER_NOTIFY_INFO_DATA  aData[1];
4502 } PRINTER_NOTIFY_INFO;
4503
4504 typedef struct _PRINTER_NOTIFY_OPTIONS_TYPE {
4505   WORD   Type;
4506   WORD   Reserved0;
4507   DWORD  Reserved1;
4508   DWORD  Reserved2;
4509   DWORD  Count;
4510   PWORD  pFields;
4511 } PRINTER_NOTIFY_OPTIONS_TYPE, *PPRINTER_NOTIFY_OPTIONS_TYPE;
4512
4513 typedef struct _PRINTER_NOTIFY_OPTIONS {
4514   DWORD  Version;
4515   DWORD  Flags;
4516   DWORD  Count;
4517   PPRINTER_NOTIFY_OPTIONS_TYPE  pTypes;
4518 } PRINTER_NOTIFY_OPTIONS;
4519
4520 typedef struct _PRINTPROCESSOR_INFO_1A {
4521   LPSTR  pName;
4522 } PRINTPROCESSOR_INFO_1A;
4523
4524 typedef struct _PRINTPROCESSOR_INFO_1W {
4525   LPWSTR pName;
4526 } PRINTPROCESSOR_INFO_1W;
4527
4528 typedef_tident(PRINTPROCESSOR_INFO_1)
4529
4530 typedef struct _PROCESS_HEAP_ENTRY {
4531   PVOID lpData;
4532   DWORD cbData;
4533   BYTE cbOverhead;
4534   BYTE iRegionIndex;
4535   WORD wFlags;
4536   DWORD dwCommittedSize;
4537   DWORD dwUnCommittedSize;
4538   LPVOID lpFirstBlock;
4539   LPVOID lpLastBlock;
4540   HANDLE hMem;
4541 } PROCESS_HEAPENTRY, *LPPROCESS_HEAP_ENTRY;
4542
4543 typedef struct _PROCESS_INFORMATION {
4544   HANDLE hProcess;
4545   HANDLE hThread;
4546   DWORD dwProcessId;
4547   DWORD dwThreadId;
4548 } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
4549
4550 typedef UINT CALLBACK (*LPFNPSPCALLBACK) (HWND, UINT, LPVOID);
4551
4552 typedef struct _PROPSHEETPAGEA {
4553   DWORD     dwSize;
4554   DWORD     dwFlags;
4555   HINSTANCE hInstance;
4556   union {
4557     LPCSTR         pszTemplate;
4558     LPCDLGTEMPLATE pResource;
4559   } u1;
4560   union {
4561     HICON   hIcon;
4562     LPCSTR  pszIcon;
4563   } u2;
4564   LPCSTR  pszTitle;
4565   DLGPROC pfnDlgProc;
4566   LPARAM  lParam;
4567   LPFNPSPCALLBACK pfnCallback;
4568   UINT   * pcRefParent;
4569 } PROPSHEETPAGEA, *LPPROPSHEETPAGEA;
4570 typedef const PROPSHEETPAGEA* LPCPROPSHEETPAGEA;
4571
4572 typedef struct _PROPSHEETPAGEW {
4573   DWORD     dwSize;
4574   DWORD     dwFlags;
4575   HINSTANCE hInstance;
4576   union {
4577     LPCWSTR        pszTemplate;
4578     LPCDLGTEMPLATE pResource;
4579   } u1;
4580   union {
4581     HICON   hIcon;
4582     LPCWSTR pszIcon;
4583   } u2;
4584   LPCWSTR pszTitle;
4585   DLGPROC pfnDlgProc;
4586   LPARAM  lParam;
4587   LPFNPSPCALLBACK pfnCallback;
4588   UINT   * pcRefParent;
4589 } PROPSHEETPAGEW, *LPPROPSHEETPAGEW;
4590 typedef const PROPSHEETPAGEW* LPCPROPSHEETPAGEW;
4591
4592 typedef_tident(PROPSHEETPAGE)
4593 typedef_tident(LPPROPSHEETPAGE)
4594 typedef_tident(LPCPROPSHEETPAGE)
4595
4596 typedef struct _PSP *HPROPSHEETPAGE;
4597
4598 typedef struct _PROPSHEETHEADERA {
4599   DWORD      dwSize;
4600   DWORD      dwFlags;
4601   HWND       hwndParent;
4602   HINSTANCE  hInstance;
4603   union {
4604     HICON   hIcon;
4605     LPCSTR  pszIcon;
4606   } u1;
4607   LPCSTR     pszCaption;
4608   UINT       nPages;
4609   union {
4610     UINT    nStartPage;
4611     LPCSTR  pStartPage;
4612   } u2;
4613   union {
4614     LPCPROPSHEETPAGEA  ppsp;
4615     HPROPSHEETPAGE    *phpage;
4616   } u3;
4617   PFNPROPSHEETCALLBACK pfnCallback;
4618 } PROPSHEETHEADERA, *LPPROPSHEETHEADERA;
4619 typedef const PROPSHEETHEADERA *LPCPROPSHEETHEADERA;
4620
4621 typedef struct _PROPSHEETHEADERW {
4622   DWORD      dwSize;
4623   DWORD      dwFlags;
4624   HWND       hwndParent;
4625   HINSTANCE  hInstance;
4626   union {
4627     HICON   hIcon;
4628     LPCWSTR pszIcon;
4629   } u1;
4630   LPCWSTR    pszCaption;
4631   UINT       nPages;
4632   union {
4633     UINT    nStartPage;
4634     LPCWSTR pStartPage;
4635   } u2;
4636   union {
4637     LPCPROPSHEETPAGEW  ppsp;
4638     HPROPSHEETPAGE    *phpage;
4639   } u3;
4640   PFNPROPSHEETCALLBACK pfnCallback;
4641 } PROPSHEETHEADERW, *LPPROPSHEETHEADERW;
4642 typedef const PROPSHEETHEADERW *LPCPROPSHEETHEADERW;
4643
4644 typedef_tident(PROPSHEETHEADER)
4645 typedef_tident(LPPROPSHEETHEADER)
4646 typedef_tident(LPCPROPSHEETHEADER)
4647
4648 /* PropertySheet callbacks */
4649 typedef WINBOOL CALLBACK (*LPFNADDPROPSHEETPAGE) (HPROPSHEETPAGE, LPARAM);
4650 typedef WINBOOL CALLBACK (*LPFNADDPROPSHEETPAGES) (LPVOID,
4651                                                    LPFNADDPROPSHEETPAGE,
4652                                                    LPARAM);
4653
4654 typedef  struct _PROTOCOL_INFOA {
4655   DWORD  dwServiceFlags;
4656   INT  iAddressFamily;
4657   INT  iMaxSockAddr;
4658   INT  iMinSockAddr;
4659   INT  iSocketType;
4660   INT  iProtocol;
4661   DWORD  dwMessageSize;
4662   LPSTR  lpProtocol;
4663 } PROTOCOL_INFOA;
4664
4665 typedef  struct _PROTOCOL_INFOW {
4666   DWORD  dwServiceFlags;
4667   INT  iAddressFamily;
4668   INT  iMaxSockAddr;
4669   INT  iMinSockAddr;
4670   INT  iSocketType;
4671   INT  iProtocol;
4672   DWORD  dwMessageSize;
4673   LPWSTR  lpProtocol;
4674 } PROTOCOL_INFOW;
4675
4676 typedef_tident(PROTOCOL_INFO)
4677
4678 typedef struct _PROVIDOR_INFO_1A {
4679   LPSTR  pName;
4680   LPSTR  pEnvironment ;
4681   LPSTR  pDLLName ;
4682 } PROVIDOR_INFO_1A;
4683
4684 typedef struct _PROVIDOR_INFO_1W {
4685   LPWSTR pName;
4686   LPWSTR pEnvironment ;
4687   LPWSTR pDLLName ;
4688 } PROVIDOR_INFO_1W;
4689
4690 typedef_tident(PROVIDOR_INFO_1)
4691
4692 typedef struct _PSHNOTIFY {
4693   NMHDR hdr;
4694   LPARAM lParam;
4695 } PSHNOTIFY,   *LPPSHNOTIFY;
4696
4697 typedef struct _punctuationA {
4698   UINT   iSize;
4699   LPSTR  szPunctuation;
4700 } PUNCTUATIONA;
4701
4702 typedef struct _punctuationW {
4703   UINT   iSize;
4704   LPWSTR szPunctuation;
4705 } PUNCTUATIONW;
4706
4707 typedef_tident(PUNCTUATION)
4708
4709 typedef struct _QUERY_SERVICE_CONFIGA {
4710   DWORD dwServiceType;
4711   DWORD dwStartType;
4712   DWORD dwErrorControl;
4713   LPSTR lpBinaryPathName;
4714   LPSTR lpLoadOrderGroup;
4715   DWORD dwTagId;
4716   LPSTR lpDependencies;
4717   LPSTR lpServiceStartName;
4718   LPSTR lpDisplayName;
4719 } QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
4720
4721 typedef struct _QUERY_SERVICE_CONFIGW {
4722   DWORD dwServiceType;
4723   DWORD dwStartType;
4724   DWORD dwErrorControl;
4725   LPWSTR lpBinaryPathName;
4726   LPWSTR lpLoadOrderGroup;
4727   DWORD dwTagId;
4728   LPWSTR lpDependencies;
4729   LPWSTR lpServiceStartName;
4730   LPWSTR lpDisplayName;
4731 } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
4732
4733 typedef_tident(QUERY_SERVICE_CONFIG)
4734 typedef_tident(LPQUERY_SERVICE_CONFIG)
4735
4736 typedef struct _QUERY_SERVICE_LOCK_STATUSA {
4737   DWORD fIsLocked;
4738   LPSTR lpLockOwner;
4739   DWORD dwLockDuration;
4740 } QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
4741
4742 typedef struct _QUERY_SERVICE_LOCK_STATUSW {
4743   DWORD fIsLocked;
4744   LPWSTR lpLockOwner;
4745   DWORD dwLockDuration;
4746 } QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;
4747
4748 typedef_tident(QUERY_SERVICE_LOCK_STATUS)
4749 typedef_tident(LPQUERY_SERVICE_LOCK_STATUS)
4750
4751 typedef  struct  _RASAMBA {
4752   DWORD    dwSize;
4753   DWORD    dwError;
4754   CHAR     szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4755   BYTE     bLana;
4756 } RASAMBA;
4757
4758 typedef  struct  _RASAMBW {
4759   DWORD    dwSize;
4760   DWORD    dwError;
4761   WCHAR    szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4762   BYTE     bLana;
4763 } RASAMBW;
4764
4765 typedef_tident(RASAMB)
4766
4767 typedef struct _RASCONNA {
4768   DWORD     dwSize;
4769   HRASCONN  hrasconn;
4770   CHAR      szEntryName[RAS_MaxEntryName + 1];
4771
4772   /* WINVER >= 0x400 */
4773   CHAR      szDeviceType[ RAS_MaxDeviceType + 1 ];
4774   CHAR      szDeviceName[ RAS_MaxDeviceName + 1 ];
4775
4776   /* WINVER >= 0x401 */
4777   CHAR      szPhonebook[ MAX_PATH ];
4778   DWORD     dwSubEntry;
4779
4780   /* WINVER >= 0x500 */
4781   GUID      guidEntry;
4782
4783   /* WINVER >= 0x501 */
4784   DWORD     dwSessionId;
4785   DWORD     dwFlags;
4786   LUID      luid;
4787 } RASCONNA ;
4788
4789 typedef struct _RASCONNW {
4790   DWORD     dwSize;
4791   HRASCONN  hrasconn;
4792   WCHAR     szEntryName[RAS_MaxEntryName + 1];
4793
4794   /* WINVER >= 0x400 */
4795   WCHAR     szDeviceType[ RAS_MaxDeviceType + 1 ];
4796   WCHAR     szDeviceName[ RAS_MaxDeviceName + 1 ];
4797
4798   /* WINVER >= 0x401 */
4799   WCHAR     szPhonebook[ MAX_PATH ];
4800   DWORD     dwSubEntry;
4801
4802   /* WINVER >= 0x500 */
4803   GUID      guidEntry;
4804
4805   /* WINVER >= 0x501 */
4806   DWORD     dwSessionId;
4807   DWORD     dwFlags;
4808   LUID      luid;
4809 } RASCONNW ;
4810
4811 typedef_tident(RASCONN)
4812
4813 typedef struct _RASCONNSTATUSA {
4814   DWORD         dwSize;
4815   RASCONNSTATE  rasconnstate;
4816   DWORD         dwError;
4817   CHAR          szDeviceType[RAS_MaxDeviceType + 1];
4818   CHAR          szDeviceName[RAS_MaxDeviceName + 1];
4819 } RASCONNSTATUSA;
4820
4821 typedef struct _RASCONNSTATUSW {
4822   DWORD         dwSize;
4823   RASCONNSTATE  rasconnstate;
4824   DWORD         dwError;
4825   WCHAR         szDeviceType[RAS_MaxDeviceType + 1];
4826   WCHAR         szDeviceName[RAS_MaxDeviceName + 1];
4827 } RASCONNSTATUSW;
4828
4829 typedef_tident(RASCONNSTATUS)
4830
4831 typedef  struct  _RASDIALEXTENSIONS {
4832   DWORD    dwSize;
4833   DWORD    dwfOptions;
4834   HWND     hwndParent;
4835   DWORD    reserved;
4836 } RASDIALEXTENSIONS;
4837
4838 typedef struct _RASDIALPARAMSA {
4839   DWORD  dwSize;
4840   CHAR   szEntryName[RAS_MaxEntryName + 1];
4841   CHAR   szPhoneNumber[RAS_MaxPhoneNumber + 1];
4842   CHAR   szCallbackNumber[RAS_MaxCallbackNumber + 1];
4843   CHAR   szUserName[UNLEN + 1];
4844   CHAR   szPassword[PWLEN + 1];
4845   CHAR   szDomain[DNLEN + 1] ;
4846 } RASDIALPARAMSA;
4847
4848 typedef struct _RASDIALPARAMSW {
4849   DWORD  dwSize;
4850   WCHAR  szEntryName[RAS_MaxEntryName + 1];
4851   WCHAR  szPhoneNumber[RAS_MaxPhoneNumber + 1];
4852   WCHAR  szCallbackNumber[RAS_MaxCallbackNumber + 1];
4853   WCHAR  szUserName[UNLEN + 1];
4854   WCHAR  szPassword[PWLEN + 1];
4855   WCHAR  szDomain[DNLEN + 1] ;
4856 } RASDIALPARAMSW;
4857
4858 typedef_tident(RASDIALPARAMS)
4859
4860 typedef struct _RASENTRYNAMEA {
4861   DWORD  dwSize;
4862   CHAR   szEntryName[RAS_MaxEntryName + 1];
4863 }RASENTRYNAMEA;
4864
4865 typedef struct _RASENTRYNAMEW {
4866   DWORD  dwSize;
4867   WCHAR  szEntryName[RAS_MaxEntryName + 1];
4868 }RASENTRYNAMEW;
4869
4870 typedef_tident(RASENTRYNAME)
4871
4872 typedef  struct  _RASPPPIPA {
4873   DWORD    dwSize;
4874   DWORD    dwError;
4875   CHAR     szIpAddress[ RAS_MaxIpAddress + 1 ];
4876 } RASPPPIPA;
4877
4878 typedef  struct  _RASPPPIPW {
4879   DWORD    dwSize;
4880   DWORD    dwError;
4881   WCHAR    szIpAddress[ RAS_MaxIpAddress + 1 ];
4882 } RASPPPIPW;
4883
4884 typedef_tident(RASPPPIP)
4885
4886 typedef  struct  _RASPPPIPXA {
4887   DWORD    dwSize;
4888   DWORD    dwError;
4889   CHAR     szIpxAddress[ RAS_MaxIpxAddress + 1 ];
4890 } RASPPPIPXA;
4891
4892 typedef  struct  _RASPPPIPXW {
4893   DWORD    dwSize;
4894   DWORD    dwError;
4895   WCHAR    szIpxAddress[ RAS_MaxIpxAddress + 1 ];
4896 } RASPPPIPXW;
4897
4898 typedef_tident(RASPPPIPX)
4899
4900 typedef  struct  _RASPPPNBFA {
4901   DWORD    dwSize;
4902   DWORD    dwError;
4903   DWORD    dwNetBiosError;
4904   CHAR     szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4905   CHAR     szWorkstationName[ NETBIOS_NAME_LEN + 1 ];
4906   BYTE     bLana;
4907 } RASPPPNBFA;
4908
4909 typedef  struct  _RASPPPNBFW {
4910   DWORD    dwSize;
4911   DWORD    dwError;
4912   DWORD    dwNetBiosError;
4913   WCHAR    szNetBiosError[ NETBIOS_NAME_LEN + 1 ];
4914   WCHAR    szWorkstationName[ NETBIOS_NAME_LEN + 1 ];
4915   BYTE     bLana;
4916 } RASPPPNBFW;
4917
4918 typedef_tident(RASPPPNBF)
4919
4920 typedef struct _RASTERIZER_STATUS {
4921   short nSize;
4922   short wFlags;
4923   short nLanguageID;
4924 } RASTERIZER_STATUS, *LPRASTERIZER_STATUS;
4925
4926 typedef struct _REASSIGN_BLOCKS {
4927   WORD   Reserved;
4928   WORD   Count;
4929   DWORD BlockNumber[1];
4930 } REASSIGN_BLOCKS ;
4931
4932 typedef struct _REMOTE_NAME_INFOA {
4933   LPSTR   lpUniversalName;
4934   LPSTR   lpConnectionName;
4935   LPSTR   lpRemainingPath;
4936 } REMOTE_NAME_INFOA;
4937
4938 typedef struct _REMOTE_NAME_INFOW {
4939   LPWSTR  lpUniversalName;
4940   LPWSTR  lpConnectionName;
4941   LPWSTR  lpRemainingPath;
4942 } REMOTE_NAME_INFOW;
4943
4944 typedef_tident(REMOTE_NAME_INFO)
4945
4946 /*
4947  TODO: OLE
4948 typedef struct _reobject {
4949   DWORD  cbStruct;
4950   LONG   cp;
4951   CLSID  clsid;
4952   LPOLEOBJECT      poleobj;
4953   LPSTORAGE        pstg;
4954   LPOLECLIENTSITE  polesite;
4955   SIZEL  sizel;
4956   DWORD  dvaspect;
4957   DWORD  dwFlags;
4958   DWORD  dwUser;
4959 } REOBJECT;
4960 */
4961
4962 typedef struct _repastespecial {
4963   DWORD  dwAspect;
4964   DWORD  dwParam;
4965 } REPASTESPECIAL;
4966
4967 typedef struct _reqresize {
4968   NMHDR nmhdr;
4969   RECT rc;
4970 } REQRESIZE;
4971
4972 typedef struct _RGNDATAHEADER {
4973   DWORD dwSize;
4974   DWORD iType;
4975   DWORD nCount;
4976   DWORD nRgnSize;
4977   RECT  rcBound;
4978 } RGNDATAHEADER;
4979
4980 typedef struct _RGNDATA {
4981   RGNDATAHEADER rdh;
4982   char          Buffer[1];
4983 } RGNDATA, *PRGNDATA, *LPRGNDATA;
4984
4985 typedef struct tagSCROLLINFO {
4986   UINT cbSize;
4987   UINT fMask;
4988   int  nMin;
4989   int  nMax;
4990   UINT nPage;
4991   int  nPos;
4992   int  nTrackPos;
4993 }   SCROLLINFO, *LPSCROLLINFO;
4994 typedef SCROLLINFO const *LPCSCROLLINFO;
4995
4996
4997 typedef struct _selchange {
4998   NMHDR nmhdr;
4999   CHARRANGE chrg;
5000   WORD seltyp;
5001 } SELCHANGE;
5002
5003 typedef struct tagSERIALKEYS {
5004   DWORD cbSize;
5005   DWORD dwFlags;
5006   LPSTR lpszActivePort;
5007   LPSTR lpszPort;
5008   DWORD iBaudRate;
5009   DWORD iPortState;
5010 } SERIALKEYS,  * LPSERIALKEYS;
5011
5012 typedef struct _SERVICE_TABLE_ENTRYA {
5013   LPSTR lpServiceName;
5014   LPSERVICE_MAIN_FUNCTIONA lpServiceProc;
5015 } SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
5016
5017 typedef struct _SERVICE_TABLE_ENTRYW {
5018   LPWSTR lpServiceName;
5019   LPSERVICE_MAIN_FUNCTIONW lpServiceProc;
5020 } SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
5021
5022 typedef_tident(SERVICE_TABLE_ENTRY)
5023 typedef_tident(LPSERVICE_TABLE_ENTRY)
5024
5025 typedef struct _SERVICE_TYPE_VALUE_ABSA {
5026   DWORD   dwNameSpace;
5027   DWORD   dwValueType;
5028   DWORD   dwValueSize;
5029   LPSTR   lpValueName;
5030   PVOID   lpValue;
5031 } SERVICE_TYPE_VALUE_ABSA;
5032
5033 typedef struct _SERVICE_TYPE_VALUE_ABSW {
5034   DWORD   dwNameSpace;
5035   DWORD   dwValueType;
5036   DWORD   dwValueSize;
5037   LPWSTR  lpValueName;
5038   PVOID   lpValue;
5039 } SERVICE_TYPE_VALUE_ABSW;
5040
5041 typedef_tident(SERVICE_TYPE_VALUE_ABS)
5042
5043 typedef struct _SERVICE_TYPE_INFO_ABSA {
5044   LPSTR                   lpTypeName;
5045   DWORD                   dwValueCount;
5046   SERVICE_TYPE_VALUE_ABSA Values[1];
5047 } SERVICE_TYPE_INFO_ABSA;
5048
5049 typedef struct _SERVICE_TYPE_INFO_ABSW {
5050   LPWSTR                  lpTypeName;
5051   DWORD                   dwValueCount;
5052   SERVICE_TYPE_VALUE_ABSW Values[1];
5053 } SERVICE_TYPE_INFO_ABSW;
5054
5055 typedef_tident(SERVICE_TYPE_INFO_ABS)
5056
5057 typedef struct _SESSION_BUFFER {
5058   UCHAR lsn;
5059   UCHAR state;
5060   UCHAR local_name[NCBNAMSZ];
5061   UCHAR remote_name[NCBNAMSZ];
5062   UCHAR rcvs_outstanding;
5063   UCHAR sends_outstanding;
5064 } SESSION_BUFFER;
5065
5066 typedef struct _SESSION_HEADER {
5067   UCHAR sess_name;
5068   UCHAR num_sess;
5069   UCHAR rcv_dg_outstanding;
5070   UCHAR rcv_any_outstanding;
5071 } SESSION_HEADER;
5072
5073 typedef enum tagSHCONTF {
5074   SHCONTF_FOLDERS = 32,
5075   SHCONTF_NONFOLDERS = 64,
5076   SHCONTF_INCLUDEHIDDEN = 128,
5077   SHCONTF_INIT_ON_FIRST_NEXT = 256,
5078   SHCONTF_NETPRINTERSRCH = 512,
5079   SHCONTF_SHAREABLE = 1024,
5080   SHCONTF_STORAGE = 2048
5081 } SHCONTF;
5082
5083 typedef struct _SHFILEINFO {
5084   HICON hIcon;
5085   int   iIcon;
5086   DWORD dwAttributes;
5087   char  szDisplayName[MAX_PATH];
5088   char  szTypeName[80];
5089 } SHFILEINFO;
5090
5091 typedef WORD FILEOP_FLAGS;
5092
5093 typedef struct _SHFILEOPSTRUCTA {
5094   HWND         hwnd;
5095   UINT         wFunc;
5096   LPCSTR       pFrom;
5097   LPCSTR       pTo;
5098   FILEOP_FLAGS fFlags;
5099   WINBOOL      fAnyOperationsAborted;
5100   LPVOID       hNameMappings;
5101   LPCSTR       lpszProgressTitle;
5102 } SHFILEOPSTRUCTA, *LPSHFILEOPSTRUCTA;
5103
5104 typedef struct _SHFILEOPSTRUCTW {
5105   HWND         hwnd;
5106   UINT         wFunc;
5107   LPCWSTR      pFrom;
5108   LPCWSTR      pTo;
5109   FILEOP_FLAGS fFlags;
5110   WINBOOL      fAnyOperationsAborted;
5111   LPVOID       hNameMappings;
5112   LPCWSTR      lpszProgressTitle;
5113 } SHFILEOPSTRUCTW, *LPSHFILEOPSTRUCTW;
5114
5115 typedef_tident(SHFILEOPSTRUCT)
5116 typedef_tident(LPSHFILEOPSTRUCT)
5117
5118 typedef enum tagSHGDN {
5119   SHGDN_NORMAL = 0,
5120   SHGDN_INFOLDER = 1,
5121   SHGDN_FORPARSING = 0x8000,
5122 } SHGNO;
5123
5124 typedef struct _SHNAMEMAPPINGA {
5125   LPSTR  pszOldPath;
5126   LPSTR  pszNewPath;
5127   int    cchOldPath;
5128   int    cchNewPath;
5129 } SHNAMEMAPPINGA, *LPSHNAMEMAPPINGA;
5130
5131 typedef struct _SHNAMEMAPPINGW {
5132   LPWSTR pszOldPath;
5133   LPWSTR pszNewPath;
5134   int    cchOldPath;
5135   int    cchNewPath;
5136 } SHNAMEMAPPINGW, *LPSHNAMEMAPPINGW;
5137
5138 typedef_tident(SHNAMEMAPPING)
5139 typedef_tident(LPSHNAMEMAPPING)
5140
5141 typedef struct tagSOUNDSENTRYA {
5142   UINT   cbSize;
5143   DWORD  dwFlags;
5144   DWORD  iFSTextEffect;
5145   DWORD  iFSTextEffectMSec;
5146   DWORD  iFSTextEffectColorBits;
5147   DWORD  iFSGrafEffect;
5148   DWORD  iFSGrafEffectMSec;
5149   DWORD  iFSGrafEffectColor;
5150   DWORD  iWindowsEffect;
5151   DWORD  iWindowsEffectMSec;
5152   LPSTR  lpszWindowsEffectDLL;
5153   DWORD  iWindowsEffectOrdinal;
5154 } SOUNDSENTRYA, *LPSOUNDSENTRYA;
5155
5156 typedef struct tagSOUNDSENTRYW {
5157   UINT   cbSize;
5158   DWORD  dwFlags;
5159   DWORD  iFSTextEffect;
5160   DWORD  iFSTextEffectMSec;
5161   DWORD  iFSTextEffectColorBits;
5162   DWORD  iFSGrafEffect;
5163   DWORD  iFSGrafEffectMSec;
5164   DWORD  iFSGrafEffectColor;
5165   DWORD  iWindowsEffect;
5166   DWORD  iWindowsEffectMSec;
5167   LPWSTR lpszWindowsEffectDLL;
5168   DWORD  iWindowsEffectOrdinal;
5169 } SOUNDSENTRYW, *LPSOUNDSENTRYW;
5170
5171 typedef_tident(SOUNDSENTRY)
5172 typedef_tident(LPSOUNDSENTRY)
5173
5174 typedef struct _STARTUPINFOA {
5175   DWORD   cb;
5176   LPSTR   lpReserved;
5177   LPSTR   lpDesktop;
5178   LPSTR   lpTitle;
5179   DWORD   dwX;
5180   DWORD   dwY;
5181   DWORD   dwXSize;
5182   DWORD   dwYSize;
5183   DWORD   dwXCountChars;
5184   DWORD   dwYCountChars;
5185   DWORD   dwFillAttribute;
5186   DWORD   dwFlags;
5187   WORD    wShowWindow;
5188   WORD    cbReserved2;
5189   LPBYTE  lpReserved2;
5190   HANDLE  hStdInput;
5191   HANDLE  hStdOutput;
5192   HANDLE  hStdError;
5193 } STARTUPINFOA, *LPSTARTUPINFOA;
5194
5195 typedef struct _STARTUPINFOW {
5196   DWORD   cb;
5197   LPWSTR  lpReserved;
5198   LPWSTR  lpDesktop;
5199   LPWSTR  lpTitle;
5200   DWORD   dwX;
5201   DWORD   dwY;
5202   DWORD   dwXSize;
5203   DWORD   dwYSize;
5204   DWORD   dwXCountChars;
5205   DWORD   dwYCountChars;
5206   DWORD   dwFillAttribute;
5207   DWORD   dwFlags;
5208   WORD    wShowWindow;
5209   WORD    cbReserved2;
5210   LPBYTE  lpReserved2;
5211   HANDLE  hStdInput;
5212   HANDLE  hStdOutput;
5213   HANDLE  hStdError;
5214 } STARTUPINFOW, *LPSTARTUPINFOW;
5215
5216 typedef_tident(STARTUPINFO)
5217 typedef_tident(LPSTARTUPINFO)
5218
5219 typedef struct tagSTICKYKEYS {
5220   DWORD cbSize;
5221   DWORD dwFlags;
5222 } STICKYKEYS, *LPSTICKYKEYS;
5223
5224 typedef struct _STRRET {
5225   UINT uType;
5226   union
5227     {
5228       LPWSTR pOleStr;
5229       UINT   uOffset;
5230       char   cStr[MAX_PATH];
5231     } DUMMYUNIONNAME;
5232 } STRRET, *LPSTRRET;
5233
5234 typedef struct _tagSTYLEBUF {
5235   DWORD  dwStyle;
5236   CHAR  szDescription[32];
5237 } STYLEBUF, *LPSTYLEBUF;
5238
5239 typedef struct tagSTYLESTRUCT {
5240   DWORD styleOld;
5241   DWORD styleNew;
5242 } STYLESTRUCT, * LPSTYLESTRUCT;
5243
5244 typedef struct _ACCESS_ALLOWED_ACE {
5245  ACE_HEADER Header;
5246  ACCESS_MASK Mask;
5247  DWORD SidStart;
5248 } ACCESS_ALLOWED_ACE;
5249
5250 typedef ACCESS_ALLOWED_ACE *PACCESS_ALLOWED_ACE;
5251
5252 typedef struct _ACCESS_DENIED_ACE {
5253  ACE_HEADER Header;
5254  ACCESS_MASK Mask;
5255  DWORD SidStart;
5256 } ACCESS_DENIED_ACE;
5257 typedef ACCESS_DENIED_ACE *PACCESS_DENIED_ACE;
5258
5259 typedef struct _SYSTEM_AUDIT_ACE {
5260  ACE_HEADER Header;
5261  ACCESS_MASK Mask;
5262  DWORD SidStart;
5263 } SYSTEM_AUDIT_ACE;
5264 typedef SYSTEM_AUDIT_ACE *PSYSTEM_AUDIT_ACE;
5265
5266 typedef struct _SYSTEM_ALARM_ACE {
5267  ACE_HEADER Header;
5268  ACCESS_MASK Mask;
5269  DWORD SidStart;
5270 } SYSTEM_ALARM_ACE;
5271 typedef SYSTEM_ALARM_ACE *PSYSTEM_ALARM_ACE;
5272
5273 typedef struct _ACCESS_ALLOWED_OBJECT_ACE {
5274  ACE_HEADER Header;
5275  ACCESS_MASK Mask;
5276  DWORD Flags;
5277  GUID ObjectType;
5278  GUID InheritedObjectType;
5279  DWORD SidStart;
5280 } ACCESS_ALLOWED_OBJECT_ACE, *PACCESS_ALLOWED_OBJECT_ACE;
5281
5282 typedef struct _ACCESS_DENIED_OBJECT_ACE {
5283  ACE_HEADER Header;
5284  ACCESS_MASK Mask;
5285  DWORD Flags;
5286  GUID ObjectType;
5287  GUID InheritedObjectType;
5288  DWORD SidStart;
5289 } ACCESS_DENIED_OBJECT_ACE, *PACCESS_DENIED_OBJECT_ACE;
5290
5291 typedef struct _SYSTEM_AUDIT_OBJECT_ACE {
5292  ACE_HEADER Header;
5293  ACCESS_MASK Mask;
5294  DWORD Flags;
5295  GUID ObjectType;
5296  GUID InheritedObjectType;
5297  DWORD SidStart;
5298 } SYSTEM_AUDIT_OBJECT_ACE, *PSYSTEM_AUDIT_OBJECT_ACE;
5299
5300 typedef struct _SYSTEM_ALARM_OBJECT_ACE {
5301  ACE_HEADER Header;
5302  ACCESS_MASK Mask;
5303  DWORD Flags;
5304  GUID ObjectType;
5305  GUID InheritedObjectType;
5306  DWORD SidStart;
5307 } SYSTEM_ALARM_OBJECT_ACE, *PSYSTEM_ALARM_OBJECT_ACE;
5308
5309 typedef struct _SYSTEM_INFO
5310 {
5311   union
5312     {
5313       DWORD dwOemId;
5314       struct
5315         {
5316           WORD wProcessorArchitecture;
5317           WORD wReserved;
5318         }
5319       s;
5320     }
5321   u;
5322   DWORD  dwPageSize;
5323   LPVOID lpMinimumApplicationAddress;
5324   LPVOID lpMaximumApplicationAddress;
5325   DWORD  dwActiveProcessorMask;
5326   DWORD  dwNumberOfProcessors;
5327   DWORD  dwProcessorType;
5328   DWORD  dwAllocationGranularity;
5329   WORD  wProcessorLevel;
5330   WORD  wProcessorRevision;
5331 } SYSTEM_INFO, *LPSYSTEM_INFO;
5332
5333 typedef struct _SYSTEM_POWER_STATUS {
5334   BYTE ACLineStatus;
5335   BYTE  BatteryFlag;
5336   BYTE  BatteryLifePercent;
5337   BYTE  Reserved1;
5338   DWORD  BatteryLifeTime;
5339   DWORD  BatteryFullLifeTime;
5340 } SYSTEM_POWER_STATUS;
5341 typedef SYSTEM_POWER_STATUS *LPSYSTEM_POWER_STATUS;
5342
5343 typedef struct _TAPE_ERASE {
5344   ULONG Type;
5345 } TAPE_ERASE;
5346
5347 typedef struct _TAPE_GET_DRIVE_PARAMETERS {
5348   BOOLEAN ECC;
5349   BOOLEAN Compression;
5350   BOOLEAN DataPadding;
5351   BOOLEAN ReportSetmarks;
5352   ULONG   DefaultBlockSize;
5353   ULONG   MaximumBlockSize;
5354   ULONG   MinimumBlockSize;
5355   ULONG   MaximumPartitionCount;
5356   ULONG   FeaturesLow;
5357   ULONG   FeaturesHigh;
5358   ULONG   EOTWarningZoneSize;
5359 } TAPE_GET_DRIVE_PARAMETERS;
5360
5361 typedef struct _TAPE_GET_MEDIA_PARAMETERS {
5362   LARGE_INTEGER   Capacity;
5363   LARGE_INTEGER   Remaining;
5364   DWORD   BlockSize;
5365   DWORD   PartitionCount;
5366   BOOLEAN WriteProtected;
5367 } TAPE_GET_MEDIA_PARAMETERS;
5368
5369 typedef struct _TAPE_GET_POSITION {
5370   ULONG Type;
5371   ULONG Partition;
5372   ULONG OffsetLow;
5373   ULONG OffsetHigh;
5374 } TAPE_GET_POSITION;
5375
5376 typedef struct _TAPE_PREPARE {
5377   ULONG Operation;
5378 } TAPE_PREPARE;
5379
5380 typedef struct _TAPE_SET_DRIVE_PARAMETERS {
5381   BOOLEAN ECC;
5382   BOOLEAN Compression;
5383   BOOLEAN DataPadding;
5384   BOOLEAN ReportSetmarks;
5385   ULONG   EOTWarningZoneSize;
5386 } TAPE_SET_DRIVE_PARAMETERS;
5387
5388 typedef struct _TAPE_SET_MEDIA_PARAMETERS {
5389   ULONG BlockSize;
5390 } TAPE_SET_MEDIA_PARAMETERS;
5391
5392 typedef struct _TAPE_SET_POSITION {
5393   ULONG Method;
5394   ULONG Partition;
5395   ULONG OffsetLow;
5396   ULONG OffsetHigh;
5397 } TAPE_SET_POSITION;
5398
5399 typedef struct _TAPE_WRITE_MARKS {
5400   ULONG Type;
5401   ULONG Count;
5402 } TAPE_WRITE_MARKS;
5403
5404 typedef struct {
5405   HINSTANCE hInst;
5406   UINT nID;
5407 } TBADDBITMAP, *LPTBADDBITMAP;
5408
5409 typedef struct _TBBUTTON {
5410   int iBitmap;
5411   int idCommand;
5412   BYTE fsState;
5413   BYTE fsStyle;
5414   DWORD dwData;
5415   int iString;
5416 } TBBUTTON,  * PTBBUTTON,  * LPTBBUTTON;
5417 typedef const TBBUTTON  * LPCTBBUTTON;
5418
5419 typedef struct {
5420   NMHDR    hdr;
5421   int      iItem;
5422   TBBUTTON tbButton;
5423   int      cchText;
5424   LPSTR    pszText;
5425 } TBNOTIFYA, *LPTBNOTIFYA;
5426
5427 typedef struct {
5428   NMHDR    hdr;
5429   int      iItem;
5430   TBBUTTON tbButton;
5431   int      cchText;
5432   LPWSTR   pszText;
5433 } TBNOTIFYW, *LPTBNOTIFYW;
5434
5435 typedef_tident(TBNOTIFY)
5436 typedef_tident(LPTBNOTIFY)
5437
5438 typedef struct {
5439   HKEY    hkr;
5440   LPCSTR  pszSubKey;
5441   LPCSTR  pszValueName;
5442 } TBSAVEPARAMSA;
5443
5444 typedef struct {
5445   HKEY    hkr;
5446   LPCWSTR pszSubKey;
5447   LPCWSTR pszValueName;
5448 } TBSAVEPARAMSW;
5449
5450 typedef_tident(TBSAVEPARAMS)
5451
5452 typedef struct _TC_HITTESTINFO {
5453   POINT pt;
5454   UINT  flags;
5455 } TC_HITTESTINFO;
5456
5457 typedef struct _TC_ITEMA {
5458   UINT   mask;
5459   UINT   lpReserved1;
5460   UINT   lpReserved2;
5461   LPSTR  pszText;
5462   int    cchTextMax;
5463   int    iImage;
5464   LPARAM lParam;
5465 } TC_ITEMA;
5466
5467 typedef struct _TC_ITEMW {
5468   UINT   mask;
5469   UINT   lpReserved1;
5470   UINT   lpReserved2;
5471   LPWSTR pszText;
5472   int    cchTextMax;
5473   int    iImage;
5474   LPARAM lParam;
5475 } TC_ITEMW;
5476
5477 typedef_tident(TC_ITEM)
5478
5479 typedef struct _TC_ITEMHEADERA {
5480   UINT   mask;
5481   UINT   lpReserved1;
5482   UINT   lpReserved2;
5483   LPSTR  pszText;
5484   int    cchTextMax;
5485   int    iImage;
5486 } TC_ITEMHEADERA;
5487
5488 typedef struct _TC_ITEMHEADERW {
5489   UINT   mask;
5490   UINT   lpReserved1;
5491   UINT   lpReserved2;
5492   LPWSTR pszText;
5493   int    cchTextMax;
5494   int    iImage;
5495 } TC_ITEMHEADERW;
5496
5497 typedef_tident(TC_ITEMHEADER)
5498
5499 typedef struct _TC_KEYDOWN {
5500   NMHDR hdr;
5501   WORD wVKey;
5502   UINT flags;
5503 } TC_KEYDOWN;
5504
5505 typedef struct _textrangeA {
5506   CHARRANGE chrg;
5507   LPSTR     lpstrText;
5508 } TEXTRANGEA;
5509
5510 typedef struct _textrangeW {
5511   CHARRANGE chrg;
5512   LPWSTR    lpstrText;
5513 } TEXTRANGEW;
5514
5515 typedef_tident(TEXTRANGE)
5516
5517 typedef struct tagTOGGLEKEYS {
5518   DWORD cbSize;
5519   DWORD dwFlags;
5520 } TOGGLEKEYS;
5521
5522 typedef struct {
5523   UINT      cbSize;
5524   UINT      uFlags;
5525   HWND      hwnd;
5526   UINT      uId;
5527   RECT      rect;
5528   HINSTANCE hinst;
5529   LPSTR     lpszText;
5530 } TOOLINFOA, *PTOOLINFOA, *LPTOOLINFOA;
5531
5532 typedef struct {
5533   UINT      cbSize;
5534   UINT      uFlags;
5535   HWND      hwnd;
5536   UINT      uId;
5537   RECT      rect;
5538   HINSTANCE hinst;
5539   LPWSTR    lpszText;
5540 } TOOLINFOW, *PTOOLINFOW, *LPTOOLINFOW;
5541
5542 typedef_tident(TOOLINFO)
5543 typedef_tident(PTOOLINFO)
5544 typedef_tident(LPTOOLINFO)
5545
5546 typedef struct {
5547   NMHDR     hdr;
5548   LPSTR     lpszText;
5549   CHAR      szText[80];
5550   HINSTANCE hinst;
5551   UINT      uFlags;
5552 } TOOLTIPTEXTA, *LPTOOLTIPTEXTA;
5553
5554 typedef struct {
5555   NMHDR     hdr;
5556   LPWSTR    lpszText;
5557   WCHAR     szText[80];
5558   HINSTANCE hinst;
5559   UINT      uFlags;
5560 } TOOLTIPTEXTW, *LPTOOLTIPTEXTW;
5561
5562 typedef_tident(TOOLTIPTEXT)
5563 typedef_tident(LPTOOLTIPTEXT)
5564
5565 typedef struct tagTPMPARAMS {
5566   UINT cbSize;
5567   RECT rcExclude;
5568 } TPMPARAMS,   *LPTPMPARAMS;
5569
5570 #if 0 /* RobD - typedef removed due to conflict with mingw headers */
5571 typedef struct _TRANSMIT_FILE_BUFFERS {
5572   PVOID Head;
5573   DWORD HeadLength;
5574   PVOID Tail;
5575   DWORD TailLength;
5576 } TRANSMIT_FILE_BUFFERS;
5577 #endif
5578
5579 typedef struct _TT_HITTESTINFOA {
5580   HWND      hwnd;
5581   POINT     pt;
5582   TOOLINFOA ti;
5583 } TTHITTESTINFOA, *LPHITTESTINFOA;
5584
5585 typedef struct _TT_HITTESTINFOW {
5586   HWND      hwnd;
5587   POINT     pt;
5588   TOOLINFOW ti;
5589 } TTHITTESTINFOW, *LPHITTESTINFOW;
5590
5591 typedef_tident(TTHITTESTINFO)
5592 typedef_tident(LPHITTESTINFO)
5593
5594 typedef struct tagTTPOLYCURVE {
5595   WORD    wType;
5596   WORD    cpfx;
5597   POINTFX apfx[1];
5598 } TTPOLYCURVE,  * LPTTPOLYCURVE;
5599
5600 typedef struct _TTPOLYGONHEADER {
5601   DWORD   cb;
5602   DWORD   dwType;
5603   POINTFX pfxStart;
5604 } TTPOLYGONHEADER, *PTTPOLYGONHEADER, *LPTTPOLYGONHEADER;
5605
5606 typedef struct _TV_DISPINFOA {
5607   NMHDR    hdr;
5608   TV_ITEMA item;
5609 } TV_DISPINFOA;
5610
5611 typedef struct _TV_DISPINFOW {
5612   NMHDR    hdr;
5613   TV_ITEMW item;
5614 } TV_DISPINFOW;
5615
5616 typedef_tident(TV_DISPINFO)
5617
5618 typedef struct _TVHITTESTINFO {
5619   POINT     pt;
5620   UINT      flags;
5621   HTREEITEM hItem;
5622 } TV_HITTESTINFO, *LPTV_HITTESTINFO;
5623
5624 typedef struct _TV_INSERTSTRUCTA {
5625   HTREEITEM hParent;
5626   HTREEITEM hInsertAfter;
5627   TV_ITEMA  item;
5628 } TV_INSERTSTRUCTA, *LPTV_INSERTSTRUCTA;
5629
5630 typedef struct _TV_INSERTSTRUCTW {
5631   HTREEITEM hParent;
5632   HTREEITEM hInsertAfter;
5633   TV_ITEMW  item;
5634 } TV_INSERTSTRUCTW, *LPTV_INSERTSTRUCTW;
5635
5636 typedef_tident(TV_INSERTSTRUCT)
5637 typedef_tident(LPTV_INSERTSTRUCT)
5638
5639 typedef struct _TV_KEYDOWN {
5640   NMHDR hdr;
5641   WORD  wVKey;
5642   UINT  flags;
5643 } TV_KEYDOWN;
5644
5645 typedef struct _TV_SORTCB {
5646   HTREEITEM    hParent;
5647   PFNTVCOMPARE lpfnCompare;
5648   LPARAM       lParam;
5649 } TV_SORTCB,   *LPTV_SORTCB;
5650
5651 typedef struct {
5652   UINT nSec;
5653   UINT nInc;
5654 } UDACCEL;
5655
5656 typedef struct _UNIVERSAL_NAME_INFOA {
5657   LPSTR   lpUniversalName;
5658 } UNIVERSAL_NAME_INFOA;
5659
5660 typedef struct _UNIVERSAL_NAME_INFOW {
5661   LPWSTR  lpUniversalName;
5662 } UNIVERSAL_NAME_INFOW;
5663
5664 typedef_tident(UNIVERSAL_NAME_INFO)
5665
5666 typedef struct tagUSEROBJECTFLAGS {
5667   WINBOOL fInherit;
5668   WINBOOL fReserved;
5669   DWORD dwFlags;
5670 } USEROBJECTFLAGS;
5671
5672 typedef struct _VERIFY_INFORMATION {
5673   LARGE_INTEGER  StartingOffset;
5674   DWORD  Length;
5675 } VERIFY_INFORMATION ;
5676
5677 typedef struct _VS_FIXEDFILEINFO {
5678   DWORD dwSignature;
5679   DWORD dwStrucVersion;
5680   DWORD dwFileVersionMS;
5681   DWORD dwFileVersionLS;
5682   DWORD dwProductVersionMS;
5683   DWORD dwProductVersionLS;
5684   DWORD dwFileFlagsMask;
5685   DWORD dwFileFlags;
5686   DWORD dwFileOS;
5687   DWORD dwFileType;
5688   DWORD dwFileSubtype;
5689   DWORD dwFileDateMS;
5690   DWORD dwFileDateLS;
5691 } VS_FIXEDFILEINFO;
5692
5693 typedef struct _WIN32_FIND_DATAA {
5694   DWORD    dwFileAttributes;
5695   FILETIME ftCreationTime;
5696   FILETIME ftLastAccessTime;
5697   FILETIME ftLastWriteTime;
5698   DWORD    nFileSizeHigh;
5699   DWORD    nFileSizeLow;
5700   DWORD    dwReserved0;
5701   DWORD    dwReserved1;
5702   CHAR     cFileName[ MAX_PATH ];
5703   CHAR     cAlternateFileName[ 14 ];
5704 } WIN32_FIND_DATAA, *LPWIN32_FIND_DATAA, *PWIN32_FIND_DATAA;
5705
5706 typedef struct _WIN32_FIND_DATAW {
5707   DWORD dwFileAttributes;
5708   FILETIME ftCreationTime;
5709   FILETIME ftLastAccessTime;
5710   FILETIME ftLastWriteTime;
5711   DWORD    nFileSizeHigh;
5712   DWORD    nFileSizeLow;
5713   DWORD    dwReserved0;
5714   DWORD    dwReserved1;
5715   WCHAR    cFileName[ MAX_PATH ];
5716   WCHAR    cAlternateFileName[ 14 ];
5717 } WIN32_FIND_DATAW, *LPWIN32_FIND_DATAW, *PWIN32_FIND_DATAW;
5718
5719 typedef_tident(WIN32_FIND_DATA)
5720 typedef_tident(PWIN32_FIND_DATA)
5721 typedef_tident(LPWIN32_FIND_DATA)
5722
5723 typedef struct _WIN32_STREAM_ID {
5724   DWORD dwStreamId;
5725   DWORD dwStreamAttributes;
5726   LARGE_INTEGER Size;
5727   DWORD dwStreamNameSize;
5728   WCHAR *cStreamName;
5729 } WIN32_STREAM_ID;
5730
5731 typedef struct _WINDOWPLACEMENT {
5732   UINT  length;
5733   UINT  flags;
5734   UINT  showCmd;
5735   POINT ptMinPosition;
5736   POINT ptMaxPosition;
5737   RECT  rcNormalPosition;
5738 } WINDOWPLACEMENT;
5739
5740 typedef struct _WNDCLASSA {
5741   UINT    style;
5742   WNDPROC lpfnWndProc;
5743   int     cbClsExtra;
5744   int     cbWndExtra;
5745   HANDLE  hInstance;
5746   HICON   hIcon;
5747   HCURSOR hCursor;
5748   HBRUSH  hbrBackground;
5749   LPCSTR  lpszMenuName;
5750   LPCSTR  lpszClassName;
5751 } WNDCLASSA, *LPWNDCLASSA;
5752
5753 typedef struct _WNDCLASSW {
5754   UINT    style;
5755   WNDPROC lpfnWndProc;
5756   int     cbClsExtra;
5757   int     cbWndExtra;
5758   HANDLE  hInstance;
5759   HICON   hIcon;
5760   HCURSOR hCursor;
5761   HBRUSH  hbrBackground;
5762   LPCWSTR lpszMenuName;
5763   LPCWSTR lpszClassName;
5764 } WNDCLASSW, *LPWNDCLASSW;
5765
5766 typedef_tident(WNDCLASS)
5767
5768 typedef struct _WNDCLASSEXA {
5769   UINT    cbSize;
5770   UINT    style;
5771   WNDPROC lpfnWndProc;
5772   int     cbClsExtra;
5773   int     cbWndExtra;
5774   HANDLE  hInstance;
5775   HICON   hIcon;
5776   HCURSOR hCursor;
5777   HBRUSH  hbrBackground;
5778   LPCSTR  lpszMenuName;
5779   LPCSTR  lpszClassName;
5780   HICON   hIconSm;
5781 } WNDCLASSEXA, *LPWNDCLASSEXA;
5782
5783 typedef struct _WNDCLASSEXW {
5784   UINT    cbSize;
5785   UINT    style;
5786   WNDPROC lpfnWndProc;
5787   int     cbClsExtra;
5788   int     cbWndExtra;
5789   HANDLE  hInstance;
5790   HICON   hIcon;
5791   HCURSOR hCursor;
5792   HBRUSH  hbrBackground;
5793   LPCWSTR lpszMenuName;
5794   LPCWSTR lpszClassName;
5795   HICON   hIconSm;
5796 } WNDCLASSEXW, *LPWNDCLASSEXW;
5797
5798 typedef_tident(WNDCLASSEX)
5799
5800 typedef struct _CONNECTDLGSTRUCTA {
5801   DWORD          cbStructure;
5802   HWND           hwndOwner;
5803   LPNETRESOURCEA lpConnRes;
5804   DWORD          dwFlags;
5805   DWORD          dwDevNum;
5806 } CONNECTDLGSTRUCTA, *LPCONNECTDLGSTRUCTA;
5807
5808 typedef struct _CONNECTDLGSTRUCTW {
5809   DWORD          cbStructure;
5810   HWND           hwndOwner;
5811   LPNETRESOURCEW lpConnRes;
5812   DWORD          dwFlags;
5813   DWORD          dwDevNum;
5814 } CONNECTDLGSTRUCTW, *LPCONNECTDLGSTRUCTW;
5815
5816 typedef_tident(CONNECTDLGSTRUCT)
5817 typedef_tident(LPCONNECTDLGSTRUCT)
5818
5819 typedef struct _DISCDLGSTRUCTA {
5820   DWORD           cbStructure;
5821   HWND            hwndOwner;
5822   LPSTR           lpLocalName;
5823   LPSTR           lpRemoteName;
5824   DWORD           dwFlags;
5825 } DISCDLGSTRUCTA, *LPDISCDLGSTRUCTA;
5826
5827 typedef struct _DISCDLGSTRUCTW {
5828   DWORD           cbStructure;
5829   HWND            hwndOwner;
5830   LPWSTR          lpLocalName;
5831   LPWSTR          lpRemoteName;
5832   DWORD           dwFlags;
5833 } DISCDLGSTRUCTW, *LPDISCDLGSTRUCTW;
5834
5835 typedef_tident(DISCDLGSTRUCT)
5836 typedef_tident(LPDISCDLGSTRUCT)
5837
5838 typedef struct _NETINFOSTRUCT{
5839     DWORD cbStructure;
5840     DWORD dwProviderVersion;
5841     DWORD dwStatus;
5842     DWORD dwCharacteristics;
5843     DWORD dwHandle;
5844     WORD  wNetType;
5845     DWORD dwPrinters;
5846     DWORD dwDrives;
5847 } NETINFOSTRUCT, *LPNETINFOSTRUCT;
5848
5849 typedef struct _NETCONNECTINFOSTRUCT{
5850   DWORD cbStructure;
5851   DWORD dwFlags;
5852   DWORD dwSpeed;
5853   DWORD dwDelay;
5854   DWORD dwOptDataSize;
5855 } NETCONNECTINFOSTRUCT, *LPNETCONNECTINFOSTRUCT;
5856
5857 typedef int CALLBACK (*ENUMMETAFILEPROC) (HDC, HANDLETABLE,
5858                                           METARECORD, int, LPARAM);
5859 typedef int CALLBACK (*ENHMETAFILEPROC) (HDC, HANDLETABLE,
5860                                          ENHMETARECORD, int, LPARAM);
5861
5862 typedef int CALLBACK (*ENUMFONTSPROCA) (LPLOGFONTA, LPTEXTMETRICA, DWORD, LPARAM);
5863 typedef int CALLBACK (*ENUMFONTSPROCW) (LPLOGFONTW, LPTEXTMETRICW, DWORD, LPARAM);
5864 typedef_tident(ENUMFONTSPROC)
5865 typedef int CALLBACK (*FONTENUMPROCA) (ENUMLOGFONTA *, NEWTEXTMETRICA *,
5866                                        int, LPARAM);
5867 typedef int CALLBACK (*FONTENUMPROCW) (ENUMLOGFONTW *, NEWTEXTMETRICW *,
5868                                        int, LPARAM);
5869 typedef_tident(FONTENUMPROC)
5870 typedef int CALLBACK (*FONTENUMEXPROCA) (ENUMLOGFONTEXA *, NEWTEXTMETRICEXA *,
5871                                          int, LPARAM);
5872 typedef int CALLBACK (*FONTENUMEXPROCW) (ENUMLOGFONTEXW *, NEWTEXTMETRICEXW *,
5873                                          int, LPARAM);
5874 typedef_tident(FONTENUMEXPROC)
5875
5876 typedef VOID CALLBACK (*LPOVERLAPPED_COMPLETION_ROUTINE) (DWORD, DWORD,
5877                                                           LPOVERLAPPED);
5878
5879 /*
5880   Structures for the extensions to OpenGL
5881   */
5882 typedef struct _POINTFLOAT
5883 {
5884   FLOAT   x;
5885   FLOAT   y;
5886 } POINTFLOAT, *PPOINTFLOAT;
5887
5888 typedef struct _GLYPHMETRICSFLOAT
5889 {
5890   FLOAT       gmfBlackBoxX;
5891   FLOAT       gmfBlackBoxY;
5892   POINTFLOAT  gmfptGlyphOrigin;
5893   FLOAT       gmfCellIncX;
5894   FLOAT       gmfCellIncY;
5895 } GLYPHMETRICSFLOAT, *PGLYPHMETRICSFLOAT, *LPGLYPHMETRICSFLOAT;
5896
5897 typedef struct tagLAYERPLANEDESCRIPTOR
5898 {
5899   WORD  nSize;
5900   WORD  nVersion;
5901   DWORD dwFlags;
5902   BYTE  iPixelType;
5903   BYTE  cColorBits;
5904   BYTE  cRedBits;
5905   BYTE  cRedShift;
5906   BYTE  cGreenBits;
5907   BYTE  cGreenShift;
5908   BYTE  cBlueBits;
5909   BYTE  cBlueShift;
5910   BYTE  cAlphaBits;
5911   BYTE  cAlphaShift;
5912   BYTE  cAccumBits;
5913   BYTE  cAccumRedBits;
5914   BYTE  cAccumGreenBits;
5915   BYTE  cAccumBlueBits;
5916   BYTE  cAccumAlphaBits;
5917   BYTE  cDepthBits;
5918   BYTE  cStencilBits;
5919   BYTE  cAuxBuffers;
5920   BYTE  iLayerPlane;
5921   BYTE  bReserved;
5922   COLORREF crTransparent;
5923 } LAYERPLANEDESCRIPTOR, *PLAYERPLANEDESCRIPTOR, *LPLAYERPLANEDESCRIPTOR;
5924
5925 typedef struct tagPIXELFORMATDESCRIPTOR
5926 {
5927   WORD  nSize;
5928   WORD  nVersion;
5929   DWORD dwFlags;
5930   BYTE  iPixelType;
5931   BYTE  cColorBits;
5932   BYTE  cRedBits;
5933   BYTE  cRedShift;
5934   BYTE  cGreenBits;
5935   BYTE  cGreenShift;
5936   BYTE  cBlueBits;
5937   BYTE  cBlueShift;
5938   BYTE  cAlphaBits;
5939   BYTE  cAlphaShift;
5940   BYTE  cAccumBits;
5941   BYTE  cAccumRedBits;
5942   BYTE  cAccumGreenBits;
5943   BYTE  cAccumBlueBits;
5944   BYTE  cAccumAlphaBits;
5945   BYTE  cDepthBits;
5946   BYTE  cStencilBits;
5947   BYTE  cAuxBuffers;
5948   BYTE  iLayerType;
5949   BYTE  bReserved;
5950   DWORD dwLayerMask;
5951   DWORD dwVisibleMask;
5952   DWORD dwDamageMask;
5953 } PIXELFORMATDESCRIPTOR, *PPIXELFORMATDESCRIPTOR, *LPPIXELFORMATDESCRIPTOR;
5954
5955 typedef struct
5956 {
5957   LPWSTR    usri2_name;
5958   LPWSTR    usri2_password;
5959   DWORD     usri2_password_age;
5960   DWORD     usri2_priv;
5961   LPWSTR    usri2_home_dir;
5962   LPWSTR    usri2_comment;
5963   DWORD     usri2_flags;
5964   LPWSTR    usri2_script_path;
5965   DWORD     usri2_auth_flags;
5966   LPWSTR    usri2_full_name;
5967   LPWSTR    usri2_usr_comment;
5968   LPWSTR    usri2_parms;
5969   LPWSTR    usri2_workstations;
5970   DWORD     usri2_last_logon;
5971   DWORD     usri2_last_logoff;
5972   DWORD     usri2_acct_expires;
5973   DWORD     usri2_max_storage;
5974   DWORD     usri2_units_per_week;
5975   PBYTE     usri2_logon_hours;
5976   DWORD     usri2_bad_pw_count;
5977   DWORD     usri2_num_logons;
5978   LPWSTR    usri2_logon_server;
5979   DWORD     usri2_country_code;
5980   DWORD     usri2_code_page;
5981 } USER_INFO_2, *PUSER_INFO_2, *LPUSER_INFO_2;
5982
5983 typedef struct
5984 {
5985   LPWSTR    usri0_name;
5986 } USER_INFO_0, *PUSER_INFO_0, *LPUSER_INFO_0;
5987
5988 typedef struct
5989 {
5990   LPWSTR    usri3_name;
5991   LPWSTR    usri3_password;
5992   DWORD     usri3_password_age;
5993   DWORD     usri3_priv;
5994   LPWSTR    usri3_home_dir;
5995   LPWSTR    usri3_comment;
5996   DWORD     usri3_flags;
5997   LPWSTR    usri3_script_path;
5998   DWORD     usri3_auth_flags;
5999   LPWSTR    usri3_full_name;
6000   LPWSTR    usri3_usr_comment;
6001   LPWSTR    usri3_parms;
6002   LPWSTR    usri3_workstations;
6003   DWORD     usri3_last_logon;
6004   DWORD     usri3_last_logoff;
6005   DWORD     usri3_acct_expires;
6006   DWORD     usri3_max_storage;
6007   DWORD     usri3_units_per_week;
6008   PBYTE     usri3_logon_hours;
6009   DWORD     usri3_bad_pw_count;
6010   DWORD     usri3_num_logons;
6011   LPWSTR    usri3_logon_server;
6012   DWORD     usri3_country_code;
6013   DWORD     usri3_code_page;
6014   DWORD     usri3_user_id;
6015   DWORD     usri3_primary_group_id;
6016   LPWSTR    usri3_profile;
6017   LPWSTR    usri3_home_dir_drive;
6018   DWORD     usri3_password_expired;
6019 } USER_INFO_3, *PUSER_INFO_3, *LPUSER_INFO_3;
6020
6021 typedef struct
6022 {
6023   LPWSTR   grpi2_name;
6024   LPWSTR   grpi2_comment;
6025   DWORD    grpi2_group_id;
6026   DWORD    grpi2_attributes;
6027 } GROUP_INFO_2, *PGROUP_INFO_2;
6028
6029 typedef struct
6030 {
6031   LPWSTR   lgrpi0_name;
6032 } LOCALGROUP_INFO_0, *PLOCALGROUP_INFO_0, *LPLOCALGROUP_INFO_0;
6033
6034 /* PE executable header.  */
6035 /* Windows.h now includes pe.h to avoid conflicts! */
6036
6037 typedef struct _DISPLAY_DEVICE {
6038   DWORD cb;
6039   WCHAR DeviceName[32];
6040   WCHAR DeviceString[128];
6041   DWORD StateFlags;
6042   WCHAR DeviceID[128];
6043   WCHAR DeviceKey[128];
6044 } DISPLAY_DEVICE, *PDISPLAY_DEVICE;
6045
6046 typedef HANDLE HMONITOR;
6047 typedef HANDLE HDEVNOTIFY;
6048
6049 typedef BOOL CALLBACK (*MonitorEnumProc)(
6050   HMONITOR hMonitor,
6051   HDC hdcMonitor,
6052   LPRECT lprcMonitor,
6053   LPARAM dwData);
6054
6055 typedef MonitorEnumProc MONITORENUMPROC;
6056
6057 typedef struct {
6058   UINT  cbSize;
6059   HWND  hwnd;
6060   DWORD dwFlags;
6061   UINT  uCount;
6062   DWORD dwTimeout;
6063 } FLASHWINFO, *PFLASHWINFO;
6064
6065 typedef struct tagALTTABINFO {
6066   DWORD cbSize;
6067   int   cItems;
6068   int   cColumns;
6069   int   cRows;
6070   int   iColFocus;
6071   int   iRowFocus;
6072   int   cxItem;
6073   int   cyItem;
6074   POINT ptStart;
6075 } ALTTABINFO, *PALTTABINFO, *LPALTTABINFO;
6076
6077 typedef struct tagCOMBOBOXINFO {
6078   DWORD cbSize;
6079   RECT  rcItem;
6080   RECT  rcButton;
6081   DWORD stateButton;
6082   HWND  hwndCombo;
6083   HWND  hwndItem;
6084   HWND  hwndList;
6085 } COMBOBOXINFO, *PCOMBOBOXINFO, *LPCOMBOBOXINFO;
6086
6087 typedef struct tagCURSORINFO {
6088   DWORD   cbSize;
6089   DWORD   flags;
6090   HCURSOR hCursor;
6091   POINT   ptScreenPos;
6092 } CURSORINFO, *PCURSORINFO, *LPCURSORINFO;
6093
6094 typedef struct tagGUITHREADINFO {
6095   DWORD   cbSize;
6096   DWORD   flags;
6097   HWND    hwndActive;
6098   HWND    hwndFocus;
6099   HWND    hwndCapture;
6100   HWND    hwndMenuOwner;
6101   HWND    hwndMoveSize;
6102   HWND    hwndCaret;
6103   RECT    rcCaret;
6104 } GUITHREADINFO, *PGUITHREADINFO, *LPGUITHREADINFO;
6105
6106 typedef struct tagLASTINPUTINFO {
6107   UINT cbSize;
6108   DWORD dwTime;
6109 } LASTINPUTINFO, *PLASTINPUTINFO;
6110
6111 typedef struct tagMENUBARINFO {
6112   DWORD cbSize;
6113   RECT  rcBar;
6114   HMENU hMenu;
6115   HWND  hwndMenu;
6116   BOOL  fBarFocused:1;
6117   BOOL  fFocused:1;
6118 } MENUBARINFO, *PMENUBARINFO;
6119
6120 typedef struct tagMENUINFO {
6121   DWORD   cbSize;
6122   DWORD   fMask;
6123   DWORD   dwStyle;
6124   UINT    cyMax;
6125   HBRUSH  hbrBack;
6126   DWORD   dwContextHelpID;
6127   ULONG_PTR  dwMenuData;
6128 } MENUINFO, FAR *LPMENUINFO;
6129 typedef MENUINFO CONST FAR *LPCMENUINFO;
6130
6131 typedef struct tagMONITORINFO {
6132   DWORD cbSize;
6133   RECT rcMonitor;
6134   RECT rcWork;
6135   DWORD dwFlags;
6136 } MONITORINFO, *LPMONITORINFO;
6137
6138 typedef struct tagMOUSEMOVEPOINT {
6139   int       x;
6140   int       y;
6141   DWORD     time;
6142   ULONG_PTR dwExtraInfo;
6143 } MOUSEMOVEPOINT, *PMOUSEMOVEPOINT, *LPMOUSEMOVEPOINT;
6144
6145 #define CCHILDREN_SCROLLBAR 5
6146
6147 typedef struct tagSCROLLBARINFO {
6148   DWORD cbSize;
6149   RECT  rcScrollBar;
6150   int   dxyLineButton;
6151   int   xyThumbTop;
6152   int   xyThumbBottom;
6153   int   reserved;
6154   DWORD rgstate[CCHILDREN_SCROLLBAR+1];
6155 } SCROLLBARINFO, *PSCROLLBARINFO, *LPSCROLLBARINFO;
6156
6157 #define CCHILDREN_TITLEBAR 5
6158
6159 typedef struct tagTITLEBARINFO {
6160   DWORD cbSize;
6161   RECT  rcTitleBar;
6162   DWORD rgstate[CCHILDREN_TITLEBAR+1];
6163 } TITLEBARINFO, *PTITLEBARINFO, *LPTITLEBARINFO;
6164
6165 typedef struct tagWINDOWINFO {
6166   DWORD   cbSize;
6167   RECT    rcWindow;
6168   RECT    rcClient;
6169   DWORD   dwStyle;
6170   DWORD   dwExStyle;
6171   DWORD   dwWindowStatus;
6172   UINT    cxWindowBorders;
6173   UINT    cyWindowBorders;
6174   ATOM    atomWindowType;
6175   WORD    wCreatorVersion;
6176 } WINDOWINFO, *PWINDOWINFO, *LPWINDOWINFO;
6177
6178 typedef struct tagMOUSEINPUT {
6179   LONG    dx;
6180   LONG    dy;
6181   DWORD   mouseData;
6182   DWORD   dwFlags;
6183   DWORD   time;
6184   ULONG_PTR   dwExtraInfo;
6185 } MOUSEINPUT, *PMOUSEINPUT;
6186
6187 typedef struct tagKEYBDINPUT {
6188   WORD      wVk;
6189   WORD      wScan;
6190   DWORD     dwFlags;
6191   DWORD     time;
6192   ULONG_PTR dwExtraInfo;
6193 } KEYBDINPUT, *PKEYBDINPUT;
6194
6195 typedef struct tagHARDWAREINPUT {
6196   DWORD   uMsg;
6197   WORD    wParamL;
6198   WORD    wParamH;
6199 } HARDWAREINPUT, *PHARDWAREINPUT;
6200
6201 typedef struct tagINPUT {
6202   DWORD type;
6203   union
6204   {
6205     MOUSEINPUT mi;
6206     KEYBDINPUT ki;
6207     HARDWAREINPUT hi;
6208   } u;
6209 } INPUT, *PINPUT, FAR* LPINPUT;
6210
6211 typedef struct tagTRACKMOUSEEVENT {
6212   DWORD cbSize;
6213   DWORD dwFlags;
6214   HWND  hwndTrack;
6215   DWORD dwHoverTime;
6216 } TRACKMOUSEEVENT, *LPTRACKMOUSEEVENT;
6217
6218 typedef IMAGE_THUNK_DATA *          PImgThunkData;
6219 typedef const IMAGE_THUNK_DATA *    PCImgThunkData;
6220
6221 typedef struct ImgDelayDescr {
6222     DWORD           grAttrs;
6223     LPCSTR          szName;
6224     HMODULE *       phmod;
6225     PImgThunkData   pIAT;
6226     PCImgThunkData  pINT;
6227     PCImgThunkData  pBoundIAT;
6228     PCImgThunkData  pUnloadIAT;
6229     DWORD           dwTimeStamp;
6230     } ImgDelayDescr, * PImgDelayDescr;
6231
6232 typedef const ImgDelayDescr *   PCImgDelayDescr;
6233
6234 typedef struct DelayLoadProc {
6235     BOOL                fImportByName;
6236     union {
6237         LPCSTR          szProcName;
6238         DWORD           dwOrdinal;
6239         };
6240     } DelayLoadProc;
6241
6242 typedef struct DelayLoadInfo {
6243     DWORD               cb;
6244     PCImgDelayDescr     pidd;
6245     FARPROC *           ppfn;
6246     LPCSTR              szDll;
6247     DelayLoadProc       dlp;
6248     HMODULE             hmodCur;
6249     FARPROC             pfnCur;
6250     DWORD               dwLastError;
6251     } DelayLoadInfo, * PDelayLoadInfo;
6252
6253 typedef struct _RTL_HEAP_TAG_INFO {
6254         ULONG AllocCount;
6255         ULONG FreeCount;
6256         ULONG MemoryUsed;
6257 } RTL_HEAP_TAG_INFO, *LPRTL_HEAP_TAG_INFO, *PRTL_HEAP_TAG_INFO;
6258
6259 typedef struct _PORT_MESSAGE {
6260         USHORT DataSize;
6261         USHORT MessageSize;
6262         USHORT MessageType;
6263         USHORT VirtualRangesOffset;
6264         CLIENT_ID ClientId;
6265         ULONG MessageId;
6266         ULONG SectionSize;
6267 //      UCHAR Data [];
6268 } PORT_MESSAGE,*PPORT_MESSAGE;
6269
6270 typedef struct _PORT_SECTION_WRITE {
6271         ULONG Length;
6272         HANDLE SectionHandle;
6273         ULONG SectionOffset;
6274         ULONG ViewSize;
6275         PVOID ViewBase;
6276         PVOID TargetViewBase;
6277 } PORT_SECTION_WRITE,*PPORT_SECTION_WRITE;
6278
6279 typedef struct _PORT_SECTION_READ {
6280         ULONG Length;
6281         ULONG ViewSize;
6282         ULONG ViewBase;
6283 } PORT_SECTION_READ,*PPORT_SECTION_READ;
6284
6285 typedef struct _FILE_USER_QUOTA_INFORMATION {
6286         ULONG NextEntryOffset;
6287         ULONG SidLength;
6288         LARGE_INTEGER ChangeTime;
6289         LARGE_INTEGER QuotaUsed;
6290         LARGE_INTEGER QuotaThreshold;
6291         LARGE_INTEGER QuotaLimit;
6292         SID Sid [1 ];
6293 } FILE_USER_QUOTA_INFORMATION,*PFILE_USER_QUOTA_INFORMATION;
6294
6295 typedef struct _FILE_QUOTA_LIST_INFORMATION {
6296         ULONG NextEntryOffset;
6297         ULONG SidLength;
6298         SID Sid [1 ];
6299 } FILE_QUOTA_LIST_INFORMATION,*PFILE_QUOTA_LIST_INFORMATION;
6300
6301 typedef struct _BLENDFUNCTION {
6302   BYTE     BlendOp;
6303   BYTE     BlendFlags;
6304   BYTE     SourceConstantAlpha;
6305   BYTE     AlphaFormat;
6306 }BLENDFUNCTION, *PBLENDFUNCTION, *LPBLENDFUNCTION;
6307
6308 typedef enum _GET_FILEEX_INFO_LEVELS {
6309     GetFileExInfoStandard
6310 } GET_FILEEX_INFO_LEVELS;
6311
6312 typedef struct _WIN32_FILE_ATTRIBUTES_DATA {
6313     DWORD    dwFileAttributes;
6314     FILETIME ftCreationTime;
6315     FILETIME ftLastAccessTime;
6316     FILETIME ftLastWriteTime;
6317     DWORD    nFileSizeHigh;
6318     DWORD    nFileSizeLow;
6319 } WIN32_FILE_ATTRIBUTE_DATA, *LPWIN32_FILE_ATTRIBUTE_DATA;
6320
6321 #ifdef __cplusplus
6322 }
6323 #endif /* __cplusplus */
6324
6325 #endif /* WIN32_LEAN_AND_MEAN */
6326
6327 #endif /* _GNU_H_WINDOWS32_STRUCTURES */