• branch=trunk inherited from [29cd5b1dde]
• sym-trunk inherited from [29cd5b1dde]

Added readme.txt version [0d3d287f0db238f3]

                                                                                        >     1  ----------------------------
                                                                                        >     2   Quasi-Bga32.DLL 2010/11/25
                                                                                        >     3  ----------------------------
                                                                                        >     4  
                                                                                        >     5  http://www.forest.impress.co.jp/article/2004/07/30/arcsecurity.html
                                                                                        >     6  などで脆弱性と指摘されている問題が気になるけれど、Bga32.dllは使い続け
                                                                                        >     7  たいという人のための回避策です。展開処理はこの問題に対処しつつ内部で
                                                                                        >     8  行い、圧縮などの他の処理は全てオリジナルのBga32.dllに処理を回します。
                                                                                        >     9  
                                                                                        >    10  本家Bga32.dllが更新されるまでのピンチヒッターということで。
                                                                                        >    11  
                                                                                        >    12  
                                                                                        >    13  ★使い方
                                                                                        >    14  
                                                                                        >    15    * オリジナルの Bga32.dll を _Bga32.dll に、名前を変更する。
                                                                                        >    16    * QBga32.dll を Bga32.dll に、名前を変更する。
                                                                                        >    17    * 後は DLL を利用する各ソフトウェアの使用方法に従って…
                                                                                        >    18  
                                                                                        >    19  ★オリジナルのBga32.DLLとの相違点
                                                                                        >    20  
                                                                                        >    21    Bga() API にxコマンドを与えたときの動作のみが変化します。
                                                                                        >    22  
                                                                                        >    23      * 書庫内の格納ファイルパスの".."を"__"に書き換えながら解凍します。
                                                                                        >    24  
                                                                                        >    25      * 今のところ、レジストリの設定を読み込みません。
                                                                                        >    26      * エラー時の返値が非常にいい加減です。
                                                                                        >    27      * 上書き確認ダイアログが簡素なものになっています。
                                                                                        >    28      * コマンドラインやオプション、ワイルドカードの解釈は
                                                                                        >    29        オリジナルと同じになるように作ったつもりです。
                                                                                        >    30      * ただし、突貫で作ったのでたぶんバグだらけです。
                                                                                        >    31  
                                                                                        >    32  ★更新履歴
                                                                                        >    33  
                                                                                        >    34    2010/11/25 (0.04)
                                                                                        >    35      * _Bga32.dll を探す対象パスからカレントディレクトリを外しました
                                                                                        >    36    2004/8/31 (0.03)
                                                                                        >    37      * レスポンスファイルが扱えてなかったバグを修正
                                                                                        >    38      * .gzaを正しく展開できないケースがあったっぽいので修正
                                                                                        >    39      * 基底ディレクトリの指定がないと正しく動作しないバグ修正
                                                                                        >    40      * 進捗状況ダイアログ表示を実装
                                                                                        >    41      * SetOwnerWindowProc系APIを実装
                                                                                        >    42      * QBgaGetVersion() API を追加。このAPIが必要になる機会は
                                                                                        >    43        基本的には無いようにしたいですが…。オリジナルの
                                                                                        >    44        Bga32と偽Bga32を区別したい場合はこのAPIの有無で。
                                                                                        >    45    2004/8/22
                                                                                        >    46      * FreeLibrary時に標準入出力を勝手に閉じちゃうバグを修正
                                                                                        >    47    2004/8/20
                                                                                        >    48      * 初版公開
                                                                                        >    49  
                                                                                        >    50  ★ソースからコンパイルするには
                                                                                        >    51  
                                                                                        >    52    Digital Mars D Compiler 0.99
                                                                                        >    53      http://www.kmonos.net/alang/d/1.0/changelog1.html#new099
                                                                                        >    54    が必要です。
                                                                                        >    55  
                                                                                        >    56  ★著作権等
                                                                                        >    57  
                                                                                        >    58    src/libbz2ディレクトリの中身は、
                                                                                        >    59      libbzip2
                                                                                        >    60        http://sources.redhat.com/bzip2/
                                                                                        >    61    をビルドしたライブラリなどです。この部分は
                                                                                        >    62      Copyright (C) 1996-2002 Julian R Seward.  All rights reserved.
                                                                                        >    63    で。
                                                                                        >    64  
                                                                                        >    65    win32.lib と win32 ディレクトリの中身は
                                                                                        >    66      windows.h for D
                                                                                        >    67        http://hp.vector.co.jp/authors/VA028375/d/windows.h.html
                                                                                        >    68    を利用しています。
                                                                                        >    69  
                                                                                        >    70    他は NYSL 0.9982 ( http://www.kmonos.net/nysl/ )に基づいてご自由に。

Added src/Makefile version [0e4ee8cbc0d43860]

                                                                                        >     1  SRCFILES  = qbga32.def qbga32.d util.d bga_melter.d hack.d windll.d qbga_gui.d
                                                                                        >     2  BZ2FILES  = libbz2\\bzlib.d libbz2\\libbz2.lib
                                                                                        >     3  DEPLIBS   = win32a.lib
                                                                                        >     4  OPTS      = -release
                                                                                        >     5  #OPTS      = -unittest
                                                                                        >     6  
                                                                                        >     7  QBga32.dll: $(SRCFILES) $(BZ2FILES)
                                                                                        >     8          dmd.exe $(OPTS) -ofQBga32.dll $(SRCFILES) $(BZ2FILES) $(DEPLIBS)
                                                                                        >     9  
                                                                                        >    10  clean:
                                                                                        >    11          del *.map
                                                                                        >    12          del *.obj

Added src/bga_melter.d version [9075347c70b2342c]

                                                                                        >     1  �ｻｿprivate import std.string;
                                                                                        >     2  private import std.file;
                                                                                        >     3  private import std.c.stdio;
                                                                                        >     4  private import etc.c.zlib;
                                                                                        >     5  private import win32.ansi.windows;
                                                                                        >     6  private import libbz2.bzlib;
                                                                                        >     7  private import util;
                                                                                        >     8  
                                                                                        >     9  //----------------------------------------------------------------
                                                                                        >    10  // Bga譖ｸ蠎ｫ縺ｮ繝輔ぃ繧､繝ｫ繝倥ャ繝�蠖｢蠑�
                                                                                        >    11  //----------------------------------------------------------------
                                                                                        >    12  
                                                                                        >    13  align(1) struct BgaHeader
                                                                                        >    14  {
                                                                                        >    15           int   checksum;        // type�ｽ枅name 縺ｮsigned char縺ｧ縺ｮ蜥�
                                                                                        >    16          char   method[4];       // "GZIP" 縺ｾ縺溘�ｯ "BZ2\0"
                                                                                        >    17          uint   compressed_size; // 蝨ｧ邵ｮ蠕後�ｮ繝�繝ｼ繧ｿ繧ｵ繧､繧ｺ( 繝倥ャ繝�縺ｯ蜷ｫ縺ｾ縺ｪ縺� )
                                                                                        >    18          uint   original_size;   // 蜈�縺ｮ繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ
                                                                                        >    19          ushort date;            // 繝輔ぃ繧､繝ｫ縺ｮ譖ｴ譁ｰ譌･莉�( DOS蠖｢蠑� )
                                                                                        >    20          ushort time;            // 繝輔ぃ繧､繝ｫ縺ｮ譖ｴ譁ｰ譎ょ綾( DOS蠖｢蠑� )
                                                                                        >    21          ubyte  attrib;          // 繝輔ぃ繧､繝ｫ縺ｮ螻樊�ｧ
                                                                                        >    22                                  // ( 1:RO 2:Hid 4:Sys 8:Vol 16:Dir 32:Arc )
                                                                                        >    23          ubyte  header_type;     // 繝倥ャ繝�縺ｮ遞ｮ鬘�( 迴ｾ蝨ｨ縺ｯ蟶ｸ縺ｫ 0 )
                                                                                        >    24          ushort arc_type;        // 繧｢繝ｼ繧ｫ繧､繝悶ち繧､繝�
                                                                                        >    25                                  // 0:(ext==竊�?髱槫悸邵ｮ:蝨ｧ邵ｮ) 1:蝨ｧ邵ｮ 2:髱槫悸邵ｮ
                                                                                        >    26                                  //      .ARC, .ARJ, .BZ2, .BZA, .CAB, .GZ, .GZA,
                                                                                        >    27                                  //      .LZS, .PAK, .RAR, .TAZ, .TBZ, .TGZ, .Z, 
                                                                                        >    28          ushort dir_name_len;    // 繝�繧｣繝ｬ繧ｯ繝医Μ蜷阪�ｮ髟ｷ縺�
                                                                                        >    29          ushort file_name_len;   // 繝輔ぃ繧､繝ｫ蜷阪�ｮ髟ｷ縺�
                                                                                        >    30          char[] fname;           // dir_name_len + file_name_len ( no '\0' )
                                                                                        >    31  }
                                                                                        >    32  
                                                                                        >    33  //----------------------------------------------------------------
                                                                                        >    34  // 繧ｨ繝ｩ繝ｼ逋ｺ逕滓凾縺ｫ謚輔£繧倶ｾ句､�
                                                                                        >    35  //----------------------------------------------------------------
                                                                                        >    36  
                                                                                        >    37  class BgaMelterError : Error
                                                                                        >    38  {
                                                                                        >    39          int errcode;
                                                                                        >    40          this( int e ) { super("BgaMelterError"); errcode=e; }
                                                                                        >    41  }
                                                                                        >    42  
                                                                                        >    43  enum
                                                                                        >    44  {
                                                                                        >    45          ERROR_FILE_OPEN=0x800D,//         繝輔ぃ繧､繝ｫ繧帝幕縺代∪縺帙ｓ縺ｧ縺励◆縲�
                                                                                        >    46          ERROR_MAKEDIRECTORY=0x8012,//     繝�繧｣繝ｬ繧ｯ繝医Μ縺御ｽ懈�舌〒縺阪∪縺帙ｓ縲�
                                                                                        >    47          ERROR_CANNOT_WRITE=0x8013,//      譖ｸ縺崎ｾｼ縺ｿ繧ｨ繝ｩ繝ｼ縺檎函縺倥∪縺励◆縲�
                                                                                        >    48          ERROR_HEADER_CRC=0x8016,//        譖ｸ蠎ｫ縺ｮ繝倥ャ繝�縺ｮ繝√ぉ繝�繧ｯ繧ｵ繝�縺悟粋縺｣縺ｦ縺�縺ｾ縺帙ｓ縲�
                                                                                        >    49          ERROR_ARC_FILE_OPEN=0x8018,//     譖ｸ蠎ｫ繧帝幕縺丈ｺ九′蜃ｺ譚･縺ｾ縺帙ｓ縲�
                                                                                        >    50          ERROR_NOT_ARC_FILE=0x8019,//      譖ｸ蠎ｫ縺ｮ繝輔ぃ繧､繝ｫ蜷阪′謖�螳壹＆繧後※縺�縺ｾ縺帙ｓ縲�
                                                                                        >    51          ERROR_CANNOT_READ=0x801A,//       繝輔ぃ繧､繝ｫ縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ譎ゅ↓繧ｨ繝ｩ繝ｼ縺�逕溘§縺ｾ縺励◆縲�
                                                                                        >    52          ERROR_FILE_STYLE=0x801B,//        謖�螳壹＆繧後◆繝輔ぃ繧､繝ｫ縺ｯ譛牙柑縺ｪ譖ｸ蠎ｫ縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縲�
                                                                                        >    53          ERROR_COMMAND_NAME=0x801C,//      繧ｳ繝槭Φ繝画欠螳壹′髢馴＆縺｣縺ｦ縺�縺ｾ縺吶��
                                                                                        >    54          ERROR_MORE_HEAP_MEMORY=0x801D,//  菴懈･ｭ逕ｨ縺ｮ縺溘ａ縺ｮ繝偵�ｼ繝励Γ繝｢繝ｪ縺御ｸ�雜ｳ縺励※縺�縺ｾ縺吶��
                                                                                        >    55          ERROR_ALREADY_RUNNING=0x801F,//   譌｢縺ｫ BGA32.DLL 縺悟虚菴應ｸｭ縺ｧ縺吶��
                                                                                        >    56          ERROR_USER_CANCEL=0x8020,//       繝ｦ繝ｼ繧ｶ繝ｼ縺ｫ繧医▲縺ｦ蜃ｦ逅�繧剃ｸｭ譁ｭ縺輔ｌ縺ｾ縺励◆縲�
                                                                                        >    57          ERROR_TMP_OPEN=0x8025,//          菴懈･ｭ繝輔ぃ繧､繝ｫ縺御ｽ懈�舌〒縺阪∪縺帙ｓ縲�
                                                                                        >    58          ERROR_ARC_READ_ONLY=0x8027,//     譖ｸ縺崎ｾｼ縺ｿ蟆ら畑螻樊�ｧ縺ｮ譖ｸ蠎ｫ縺ｫ蟇ｾ縺吶ｋ謫堺ｽ懊�ｯ縺ｧ縺阪∪縺帙ｓ縲�
                                                                                        >    59          ERROR_NOT_FIND_ARC_FILE=0x8029,// 謖�螳壹＆繧後◆繝�繧｣繝ｬ繧ｯ繝医Μ縺ｫ縺ｯ譖ｸ蠎ｫ縺後≠繧翫∪縺帙ｓ縺ｧ縺励◆縲�
                                                                                        >    60          ERROR_RESPONSE_READ=0x802A,//     繝ｬ繧ｹ繝昴Φ繧ｹ繝輔ぃ繧､繝ｫ縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ譎�縺ｫ繧ｨ繝ｩ繝ｼ縺檎函縺倥∪縺励◆縲�
                                                                                        >    61          ERROR_TMP_COPY=0x802C,//          菴懈･ｭ繝輔ぃ繧､繝ｫ縺ｮ譖ｸ蠎ｫ縺ｸ縺ｮ譖ｸ縺肴綾縺�縺後〒縺阪∪縺帙ｓ縺ｧ縺励◆縲�
                                                                                        >    62          ERROR_NOT_FIND_FILE=0x8031,//     繝輔ぃ繧､繝ｫ縺瑚ｦ九▽縺九ｊ縺ｾ縺帙ｓ縲�
                                                                                        >    63          ERROR_GET_ATTRIBUTES=0x8034,//    繝輔ぃ繧､繝ｫ螻樊�ｧ縺悟叙蠕励〒縺阪∪縺帙ｓ縲�
                                                                                        >    64          ERROR_GET_INFORMATION=0x8036,//   繝輔ぃ繧､繝ｫ諠�蝣ｱ縺悟叙蠕励〒縺阪∪縺帙ｓ縲�
                                                                                        >    65  }
                                                                                        >    66  
                                                                                        >    67  //----------------------------------------------------------------
                                                                                        >    68  // 繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ髢｢謨ｰ縺ｮ霑皮ｭ皮畑蝙�
                                                                                        >    69  //----------------------------------------------------------------
                                                                                        >    70  
                                                                                        >    71  enum BgaAnswer
                                                                                        >    72  {
                                                                                        >    73          MeltIt, SkipIt, Abort
                                                                                        >    74  }
                                                                                        >    75  
                                                                                        >    76  //----------------------------------------------------------------
                                                                                        >    77  // Filep
                                                                                        >    78  //   D險�隱槭ｉ縺励°繧峨〓縺ｮ縺ｧ縺吶′zlib繧�libbz2縺ｨ邁｡蜊倥↓騾｣謳ｺ縺吶ｋ
                                                                                        >    79  //   驛ｽ蜷井ｸ郭td.c.stdio.FILE*縺ｧ繝輔ぃ繧､繝ｫ繧定ｪｭ縺ｿ譖ｸ縺阪＠縺ｾ縺吶��
                                                                                        >    80  //----------------------------------------------------------------
                                                                                        >    81  
                                                                                        >    82  extern(C)
                                                                                        >    83  {
                                                                                        >    84          // stdio.h
                                                                                        >    85      int fileno( FILE *fp ) { return fp._file; }
                                                                                        >    86          // io.h
                                                                                        >    87          int lseek( int fd, int offset, int mode );
                                                                                        >    88          int dup( int fd );
                                                                                        >    89          int close( int fd );
                                                                                        >    90  }
                                                                                        >    91  
                                                                                        >    92  class Filep
                                                                                        >    93  {
                                                                                        >    94          private FILE* fp;
                                                                                        >    95          private this( FILE* p ) { fp = p; }
                                                                                        >    96  
                                                                                        >    97          static Filep open( char[] filename, bool read )
                                                                                        >    98          {
                                                                                        >    99                  FILE* fp = fopen( toStringz(filename), read?"rb":"wb" );
                                                                                        >   100                  return (fp ? new Filep(fp) : null);
                                                                                        >   101          }
                                                                                        >   102  
                                                                                        >   103          int dup_han()
                                                                                        >   104          {
                                                                                        >   105                  int fd = dup( fileno(fp) );
                                                                                        >   106                  lseek( fd, cur(), 0 );
                                                                                        >   107                  return fd;
                                                                                        >   108          }
                                                                                        >   109  
                                                                                        >   110          void[] read( int siz )
                                                                                        >   111          {
                                                                                        >   112                  char[] buf; buf.length = siz;
                                                                                        >   113                  int rsiz = fread( buf, 1, siz, fp );
                                                                                        >   114                  if( rsiz < 0 )
                                                                                        >   115                          throw new BgaMelterError(ERROR_FILE_OPEN);
                                                                                        >   116                  buf.length = rsiz;
                                                                                        >   117                  return buf;
                                                                                        >   118          }
                                                                                        >   119  
                                                                                        >   120          void write( void[] buf )
                                                                                        >   121          {
                                                                                        >   122                  while( buf.length > 0 )
                                                                                        >   123                  {
                                                                                        >   124                          int rsiz = fwrite( buf, 1, buf.length, fp );
                                                                                        >   125                          if( rsiz < 0 ) return;
                                                                                        >   126                          buf = buf[rsiz .. length];
                                                                                        >   127                  }
                                                                                        >   128          }
                                                                                        >   129  
                                                                                        >   130          int cur()
                                                                                        >   131          {
                                                                                        >   132                  return ftell(fp);
                                                                                        >   133          }
                                                                                        >   134  
                                                                                        >   135          void seek_to( int i )
                                                                                        >   136          {
                                                                                        >   137                  fseek( fp, i, std.c.stdio.SEEK_SET );
                                                                                        >   138          }
                                                                                        >   139  
                                                                                        >   140          void close()
                                                                                        >   141          {
                                                                                        >   142                  fclose(fp);
                                                                                        >   143          }
                                                                                        >   144  
                                                                                        >   145          FILE* get_fp()
                                                                                        >   146          {
                                                                                        >   147                  return fp;
                                                                                        >   148          }
                                                                                        >   149  }
                                                                                        >   150  
                                                                                        >   151  
                                                                                        >   152  //----------------------------------------------------------------
                                                                                        >   153  // 繝｡繧､繝ｳ繧ｯ繝ｩ繧ｹ
                                                                                        >   154  //----------------------------------------------------------------
                                                                                        >   155  
                                                                                        >   156  class BgaMelter
                                                                                        >   157  {
                                                                                        >   158          alias BgaAnswer delegate(inout BgaHeader) FileHandler;
                                                                                        >   159          alias BgaAnswer delegate(int, int)        ProgressHandler;
                                                                                        >   160  
                                                                                        >   161          private Filep fp = null;
                                                                                        >   162  
                                                                                        >   163          this( char[] arc_name )
                                                                                        >   164          {
                                                                                        >   165                  fp = Filep.open( arc_name, true );
                                                                                        >   166                  if( fp is null )
                                                                                        >   167                          throw new BgaMelterError(ERROR_FILE_OPEN);
                                                                                        >   168          }
                                                                                        >   169  
                                                                                        >   170          void close()
                                                                                        >   171          {
                                                                                        >   172                  if( fp ) { fp.close(); fp = null; }
                                                                                        >   173          }
                                                                                        >   174  
                                                                                        >   175          void start( FileHandler fh, ProgressHandler ph )
                                                                                        >   176          {
                                                                                        >   177                  try
                                                                                        >   178                  {
                                                                                        >   179                          // 繝倥ャ繝�繧呈爾縺�
                                                                                        >   180                          int hpos = find_header();
                                                                                        >   181                          if( hpos == -1 )
                                                                                        >   182                                  throw new BgaMelterError(ERROR_NOT_ARC_FILE);
                                                                                        >   183                          fp.seek_to(hpos);
                                                                                        >   184  
                                                                                        >   185                          // 繝ｫ繝ｼ繝暦ｼ�
                                                                                        >   186                          // 繝倥ャ繝�隱ｭ縺ｿ縺ｨ繧�
                                                                                        >   187                          BgaHeader hdr;
                                                                                        >   188                          while( read_header(hdr) )
                                                                                        >   189                          {
                                                                                        >   190                                  // 谺｡縺ｮ繝倥ャ繝�菴咲ｽｮ繧定ｨ育ｮ励＠縺ｦ縺翫￥
                                                                                        >   191                                  uint nextpos = fp.cur() + hdr.compressed_size;
                                                                                        >   192                                  try
                                                                                        >   193                                  {
                                                                                        >   194                                          // callback
                                                                                        >   195                                          BgaAnswer a = fh(hdr);
                                                                                        >   196                                          if( a == BgaAnswer.Abort )  return;
                                                                                        >   197                                          if( a == BgaAnswer.SkipIt ) continue;
                                                                                        >   198  
                                                                                        >   199                                          // 蜃ｺ蜉帛�医ヵ繧｡繧､繝ｫ繧帝幕縺�
                                                                                        >   200                                          if( lastChar(hdr.fname)=='\\' )
                                                                                        >   201                                            { pathMake(hdr.fname); continue; }
                                                                                        >   202  
                                                                                        >   203                                          Filep outf = Filep.open( pathMake(hdr.fn
                                                                                        >   204                                          if( outf is null )
                                                                                        >   205                                                  throw new BgaMelterError(ERROR_F
                                                                                        >   206  
                                                                                        >   207                                          // 隗｣蜃榊�ｦ逅�
                                                                                        >   208                                          bool bContinue = true;
                                                                                        >   209                                          if( !is_compressed(hdr) )
                                                                                        >   210                                                  bContinue = NcDec( hdr.original_
                                                                                        >   211                                          else if( hdr.method == "GZIP" )
                                                                                        >   212                                                  bContinue = GzDec( hdr.compresse
                                                                                        >   213                                          else if( hdr.method == "BZ2\0" )
                                                                                        >   214                                                  bContinue = BzDec( hdr.original_
                                                                                        >   215  
                                                                                        >   216                                          // 髢峨§縺ｦ螻樊�ｧ險ｭ螳�
                                                                                        >   217                                          outf.close();
                                                                                        >   218                                          dosSetFTime( hdr.fname, hdr.date, hdr.ti
                                                                                        >   219                                          SetFileAttributes( hdr.fname, hdr.attrib
                                                                                        >   220                                          if( !bContinue )
                                                                                        >   221                                                  return;
                                                                                        >   222                                  }
                                                                                        >   223                                  finally { fp.seek_to(nextpos); }
                                                                                        >   224                          }
                                                                                        >   225                  }
                                                                                        >   226                  finally { close(); }
                                                                                        >   227          }
                                                                                        >   228  
                                                                                        >   229          static int signed_char( char c )
                                                                                        >   230          {
                                                                                        >   231                  int cn = c;
                                                                                        >   232                  return (cn>=0x80 ? cn|0xffffff00 : cn);
                                                                                        >   233          }
                                                                                        >   234  
                                                                                        >   235          private int find_header()
                                                                                        >   236          {
                                                                                        >   237                  char[] dat = cast(char[]) fp.read(0x10000);
                                                                                        >   238  
                                                                                        >   239                  for( int i=0; i<dat.length-28; ++i )
                                                                                        >   240                  {
                                                                                        >   241                          if( dat[i+4]!='G' && dat[i+4]!='B' ) continue;
                                                                                        >   242                          if( dat[i+5]!='Z'                  ) continue;
                                                                                        >   243                          if( dat[i+6]!='I' && dat[i+6]!='2' ) continue;
                                                                                        >   244                          if( dat[i+7]!='P' && dat[i+7]!='\0') continue;
                                                                                        >   245  
                                                                                        >   246                           int checksum = dat[i+0]+(dat[i+1]<<8)+(dat[i+2]<<16)+(d
                                                                                        >   247                          uint fnlen    = dat[i+24]+(dat[i+25]<<8)+dat[i+26]+(dat[
                                                                                        >   248                          if( i+28+fnlen > dat.length )        continue;
                                                                                        >   249  
                                                                                        >   250                          int sum = 0;
                                                                                        >   251                          for( int j=i+4; j!=i+28+fnlen; ++j )
                                                                                        >   252                                  sum += signed_char(dat[j]);
                                                                                        >   253                          if( checksum == sum )
                                                                                        >   254                                  return i;
                                                                                        >   255                  }
                                                                                        >   256  
                                                                                        >   257                  return -1;
                                                                                        >   258          }
                                                                                        >   259  
                                                                                        >   260          private bool read_header( out BgaHeader hdr )
                                                                                        >   261          {
                                                                                        >   262                  // 繝ｪ繝医Ν繧ｨ繝ｳ繝�繧｣繧｢繝ｳ繧剃ｻｮ螳壹�ゅ�倥ャ繝�隱ｭ縺ｿ霎ｼ縺ｿ
                                                                                        >   263                  char[] buf = cast(char[]) fp.read(28);
                                                                                        >   264                  if( buf.length < 28 ) return false;
                                                                                        >   265                  buf.length = BgaHeader.sizeof;
                                                                                        >   266                  hdr = (cast(BgaHeader[]) buf)[0];
                                                                                        >   267                  hdr.fname = "";
                                                                                        >   268  
                                                                                        >   269                  // 繝輔ぃ繧､繝ｫ蜷�
                                                                                        >   270                  hdr.fname = cast(char[]) fp.read(hdr.dir_name_len + hdr.file_nam
                                                                                        >   271                  if( hdr.fname.length < hdr.dir_name_len + hdr.file_name_len ) re
                                                                                        >   272  
                                                                                        >   273                  // 繝√ぉ繝�繧ｯ繧ｵ繝�
                                                                                        >   274                  int sum = 0;
                                                                                        >   275                  for( int i=4; i!=28; ++i )    sum += signed_char(buf[i]);
                                                                                        >   276                  foreach( char c ; hdr.fname ) sum += signed_char(c);
                                                                                        >   277                  return (sum == hdr.checksum);
                                                                                        >   278          }
                                                                                        >   279  
                                                                                        >   280          private bool is_compressed( inout BgaHeader hdr ) // inout=just for opti
                                                                                        >   281          {
                                                                                        >   282                  // 繝倥ャ繝�縺九ｉ縲√ヵ繧｡繧､繝ｫ縺悟悸邵ｮ譬ｼ邏阪＆繧後※縺�繧九°縺ｩ縺�縺九ｒ蛻､螳�
                                                                                        >   283                  if( hdr.arc_type==2 )
                                                                                        >   284                          return false;
                                                                                        >   285                  if( hdr.arc_type==0 && hdr.compressed_size==hdr.original_size )
                                                                                        >   286                  {
                                                                                        >   287                          int x = rfind( hdr.fname, '.' );
                                                                                        >   288                          if( x == -1 )
                                                                                        >   289                                  return true;
                                                                                        >   290                          char[] ext = tolower(hdr.fname[x+1 .. length]);
                                                                                        >   291                          if( ext=="arc" || ext=="arj" || ext=="bz2" || ext=="bza"
                                                                                        >   292                           || ext=="cab" || ext=="gz"  || ext=="gza" || ext=="lzh"
                                                                                        >   293                           || ext=="lzs" || ext=="pak" || ext=="rar" || ext=="taz"
                                                                                        >   294                           || ext=="tbz" || ext=="tgz" || ext=="z"   || ext=="zip"
                                                                                        >   295                           || ext=="zoo" )
                                                                                        >   296                                  return false;
                                                                                        >   297                  }
                                                                                        >   298                  return true;
                                                                                        >   299          }
                                                                                        >   300  
                                                                                        >   301          static char[] pathMake( char[] path )
                                                                                        >   302          {
                                                                                        >   303                  char* ps = toStringz(path);
                                                                                        >   304                  for(char* p=ps;;)
                                                                                        >   305                  {
                                                                                        >   306                          for(; *p!=0&&*p!='\\'&&*p!='/'; p=CharNext(p)) {}
                                                                                        >   307                          if( *p==0 )
                                                                                        >   308                                  break;
                                                                                        >   309                          CreateDirectory( toStringz(ps[0..(p-ps)]), null );
                                                                                        >   310                          ++p;
                                                                                        >   311                  }
                                                                                        >   312                  return path;
                                                                                        >   313          }
                                                                                        >   314  
                                                                                        >   315          enum { BUFSIZ = 65536 }
                                                                                        >   316  
                                                                                        >   317          private bool NcDec( uint usiz, Filep outf, ProgressHandler ph )
                                                                                        >   318          {
                                                                                        >   319                  uint init_usiz = usiz;
                                                                                        >   320  
                                                                                        >   321                  // 髱槫悸邵ｮ縲ゅさ繝斐�ｼ縺吶ｋ縺�縺�
                                                                                        >   322                  while( usiz )
                                                                                        >   323                  {
                                                                                        >   324                          char[] r = cast(char[]) fp.read( BUFSIZ<usiz?BUFSIZ:usiz
                                                                                        >   325                          usiz -= r.length;
                                                                                        >   326                          outf.write(r);
                                                                                        >   327  
                                                                                        >   328                          // dlg
                                                                                        >   329                          if( BgaAnswer.Abort==ph(init_usiz-usiz,usiz) ) return fa
                                                                                        >   330                  }
                                                                                        >   331  
                                                                                        >   332                  // dlg
                                                                                        >   333                  if( BgaAnswer.Abort==ph(init_usiz-usiz,usiz) ) return false;
                                                                                        >   334                  return true;
                                                                                        >   335          }
                                                                                        >   336  
                                                                                        >   337          private bool GzDec( uint csiz, uint usiz, Filep outf, ProgressHandler ph
                                                                                        >   338          {
                                                                                        >   339                  uint init_usiz = usiz;
                                                                                        >   340  
                                                                                        >   341                  // zlib縺ｧ螻暮幕
                                                                                        >   342                  fp.read(10); csiz -= 10; // 繝倥ャ繝�,繝輔ャ繧ｿ繧ｹ繧ｭ繝�繝�
                                                                                        >   343  
                                                                                        >   344                  ubyte[]  inbuf;  inbuf.length = 65536;
                                                                                        >   345                  ubyte[] outbuf; outbuf.length = 65536;
                                                                                        >   346  
                                                                                        >   347                  // zlib貅門ｙ
                                                                                        >   348                  z_stream zs;
                                                                                        >   349                  zs.zalloc   = null;
                                                                                        >   350                  zs.zfree    = null;
                                                                                        >   351  
                                                                                        >   352                  // 蜃ｺ蜉帙ヰ繝�繝輔ぃ
                                                                                        >   353                  zs.next_out  = outbuf;
                                                                                        >   354                  zs.avail_out = outbuf.length;
                                                                                        >   355  
                                                                                        >   356                  // 蜈･蜉帙ヰ繝�繝輔ぃ
                                                                                        >   357                  inbuf = cast(ubyte[]) fp.read( csiz<65536 ? csiz : 65536 );
                                                                                        >   358                  csiz       -= inbuf.length;
                                                                                        >   359                  zs.next_in  = inbuf;
                                                                                        >   360                  zs.avail_in = inbuf.length;
                                                                                        >   361  
                                                                                        >   362                  // 繧ｹ繧ｿ繝ｼ繝�
                                                                                        >   363                  inflateInit2( &zs, -15 );
                                                                                        >   364                  try {
                                                                                        >   365  
                                                                                        >   366                  // 譖ｸ蠎ｫ縺九ｉ蜈･蜉帙＠邨ゅｏ繧九∪縺ｧ繝ｫ繝ｼ繝�
                                                                                        >   367                  int err = Z_OK;
                                                                                        >   368                  while( csiz&&usiz )
                                                                                        >   369                  {
                                                                                        >   370                          while( zs.avail_out > 0 )
                                                                                        >   371                          {
                                                                                        >   372                                  err = etc.c.zlib.inflate( &zs, Z_PARTIAL_FLUSH )
                                                                                        >   373                                  if( err!=Z_STREAM_END && err!=Z_OK )
                                                                                        >   374                                          csiz=0;
                                                                                        >   375                                  if( !csiz )
                                                                                        >   376                                          break;
                                                                                        >   377  
                                                                                        >   378                                  if( zs.avail_in<=0 )
                                                                                        >   379                                  {
                                                                                        >   380                                          inbuf = cast(ubyte[]) fp.read( csiz<6553
                                                                                        >   381                                          csiz       -= inbuf.length;
                                                                                        >   382                                          zs.next_in  = inbuf;
                                                                                        >   383                                          zs.avail_in = inbuf.length;
                                                                                        >   384  
                                                                                        >   385                                          if( inbuf.length==0 )
                                                                                        >   386                                          {
                                                                                        >   387                                                  err  = Z_STREAM_END;
                                                                                        >   388                                                  csiz = 0;
                                                                                        >   389                                                  break;
                                                                                        >   390                                          }
                                                                                        >   391                                  }
                                                                                        >   392                          }
                                                                                        >   393  
                                                                                        >   394                          int written = outbuf.length - zs.avail_out;
                                                                                        >   395                          if( usiz < written ) written = usiz;
                                                                                        >   396                          usiz -= written;
                                                                                        >   397                          outf.write( outbuf[0..written] );
                                                                                        >   398                          zs.next_out  = outbuf;
                                                                                        >   399                          zs.avail_out = outbuf.length;
                                                                                        >   400  
                                                                                        >   401                          // dlg
                                                                                        >   402                          if( BgaAnswer.Abort==ph(init_usiz-usiz,usiz) ) return fa
                                                                                        >   403                  }
                                                                                        >   404  
                                                                                        >   405                  // 蜃ｺ蜉帶ｮ九＠繧堤┌縺上☆縲�
                                                                                        >   406                  while( err!=Z_STREAM_END&&usiz )
                                                                                        >   407                  {
                                                                                        >   408                          err = etc.c.zlib.inflate(&zs,Z_PARTIAL_FLUSH);
                                                                                        >   409                          if( err!=Z_STREAM_END && err!=Z_OK )
                                                                                        >   410                                  break;
                                                                                        >   411  
                                                                                        >   412                          int written = outbuf.length - zs.avail_out;
                                                                                        >   413                          if( usiz < written ) written = usiz;
                                                                                        >   414                          usiz -= written;
                                                                                        >   415                          outf.write( outbuf[0..written] );
                                                                                        >   416                          zs.next_out  = outbuf;
                                                                                        >   417                          zs.avail_out = outbuf.length;
                                                                                        >   418  
                                                                                        >   419                          // dlg
                                                                                        >   420                          if( BgaAnswer.Abort==ph(init_usiz-usiz,usiz) ) return fa
                                                                                        >   421                  }
                                                                                        >   422  
                                                                                        >   423                  // 邨ゆｺ�
                                                                                        >   424                  } finally { inflateEnd(&zs); }
                                                                                        >   425  
                                                                                        >   426                  // dlg
                                                                                        >   427                  if( BgaAnswer.Abort==ph(init_usiz-usiz,usiz) ) return false;
                                                                                        >   428                  return true;
                                                                                        >   429          }
                                                                                        >   430  
                                                                                        >   431          private bool BzDec( uint usiz, Filep outf, ProgressHandler ph )
                                                                                        >   432          {
                                                                                        >   433                  uint init_usiz = usiz;
                                                                                        >   434  
                                                                                        >   435                  // libbz2縺ｧ螻暮幕
                                                                                        >   436                  int err;
                                                                                        >   437                  BZFILE* b = BZ2_bzReadOpen( &err, fp.get_fp(), 0, 0, NULL, 0 );
                                                                                        >   438                  if( err!=BZ_OK || b is null )
                                                                                        >   439                          return true;
                                                                                        >   440  
                                                                                        >   441                  try
                                                                                        >   442                  {
                                                                                        >   443                          char[] buf; buf.length = BUFSIZ;
                                                                                        >   444                          int len;
                                                                                        >   445                          while( 0<(len=BZ2_bzRead( &err, b, buf, BUFSIZ<usiz?BUFS
                                                                                        >   446                          {
                                                                                        >   447                                  outf.write( buf[0..len] );
                                                                                        >   448                                  usiz -= len;
                                                                                        >   449                                  if( err != BZ_OK )
                                                                                        >   450                                          break;
                                                                                        >   451  
                                                                                        >   452                                  // dlg
                                                                                        >   453                                  if( BgaAnswer.Abort==ph(init_usiz-usiz,usiz) ) r
                                                                                        >   454                          }
                                                                                        >   455                  } finally { BZ2_bzReadClose( &err, b ); }
                                                                                        >   456  
                                                                                        >   457                  // dlg
                                                                                        >   458                  if( BgaAnswer.Abort==ph(init_usiz-usiz,usiz) ) return false;
                                                                                        >   459                  return true;
                                                                                        >   460          }
                                                                                        >   461  }

Added src/hack.d version [3a5fb6fa17d9e24a]

                                                                                        >     1  private import win32.ansi.windows;
                                                                                        >     2  
                                                                                        >     3  // Hack!
                                                                                        >     4  //
                                                                                        >     5  // _acrtused_dll縺悟享謇九↓邨ゆｺ�譎ゅ↓讓呎ｺ門�･蜃ｺ蜉帙ワ繝ｳ繝峨Ν繧�
                                                                                        >     6  // 髢峨§縺｡繧�縺｣縺ｦ蝗ｰ繧九�ｮ縺ｧ縲√◎縺ｮ霎ｺ繧翫□縺代�ｯ髢峨§縺ｪ縺�繧医≧縺ｪ
                                                                                        >     7  // CloseHandle繧堤ｪ√▲霎ｼ繧薙〒蝗樣∩縲ゅ＞縺�縺ｮ縺九％繧後��
                                                                                        >     8  
                                                                                        >     9  extern(Windows)
                                                                                        >    10  {
                                                                                        >    11          private alias BOOL function(HANDLE) ClHnT;
                                                                                        >    12          private ClHnT  Real_CloseHandle;
                                                                                        >    13          private HANDLE stdin;
                                                                                        >    14          private HANDLE stdout;
                                                                                        >    15          private HANDLE stderr;
                                                                                        >    16  
                                                                                        >    17          BOOL CloseHandle( HANDLE h )
                                                                                        >    18          {
                                                                                        >    19                  if( h==stdin  ) return TRUE;
                                                                                        >    20                  if( h==stdout ) return TRUE;
                                                                                        >    21                  if( h==stderr ) return TRUE;
                                                                                        >    22                  return Real_CloseHandle(h);
                                                                                        >    23          }
                                                                                        >    24  }
                                                                                        >    25  
                                                                                        >    26  static this()
                                                                                        >    27  {
                                                                                        >    28          Real_CloseHandle = cast(ClHnT)
                                                                                        >    29                  GetProcAddress( GetModuleHandle("kernel32.dll"), "CloseHandle" )
                                                                                        >    30          stdin  = GetStdHandle(STD_INPUT_HANDLE );
                                                                                        >    31          stdout = GetStdHandle(STD_OUTPUT_HANDLE);
                                                                                        >    32          stderr = GetStdHandle(STD_ERROR_HANDLE );
                                                                                        >    33  }

Added src/libbz2/LICENSE version [e01790025972d525]

                                                                                        >     1  
                                                                                        >     2  This program, "bzip2" and associated library "libbzip2", are
                                                                                        >     3  copyright (C) 1996-2002 Julian R Seward.  All rights reserved.
                                                                                        >     4  
                                                                                        >     5  Redistribution and use in source and binary forms, with or without
                                                                                        >     6  modification, are permitted provided that the following conditions
                                                                                        >     7  are met:
                                                                                        >     8  
                                                                                        >     9  1. Redistributions of source code must retain the above copyright
                                                                                        >    10     notice, this list of conditions and the following disclaimer.
                                                                                        >    11  
                                                                                        >    12  2. The origin of this software must not be misrepresented; you must
                                                                                        >    13     not claim that you wrote the original software.  If you use this
                                                                                        >    14     software in a product, an acknowledgment in the product
                                                                                        >    15     documentation would be appreciated but is not required.
                                                                                        >    16  
                                                                                        >    17  3. Altered source versions must be plainly marked as such, and must
                                                                                        >    18     not be misrepresented as being the original software.
                                                                                        >    19  
                                                                                        >    20  4. The name of the author may not be used to endorse or promote
                                                                                        >    21     products derived from this software without specific prior written
                                                                                        >    22     permission.
                                                                                        >    23  
                                                                                        >    24  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
                                                                                        >    25  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
                                                                                        >    26  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                                                                                        >    27  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
                                                                                        >    28  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                                                                                        >    29  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
                                                                                        >    30  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                                                                                        >    31  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
                                                                                        >    32  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
                                                                                        >    33  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
                                                                                        >    34  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                                                                                        >    35  
                                                                                        >    36  Julian Seward, Cambridge, UK.
                                                                                        >    37  jseward@acm.org
                                                                                        >    38  bzip2/libbzip2 version 1.0.2 of 30 December 2001
                                                                                        >    39  

Added src/libbz2/bzlib.d version [cc821f48ad26f7f1]

                                                                                        >     1  �ｻｿmodule libbz2.bzlib;
                                                                                        >     2  private import std.c.stdio;
                                                                                        >     3  
                                                                                        >     4  //----------------------------------------------------------------
                                                                                        >     5  // bzlib.d :
                                                                                        >     6  //   manually translated from "bzlib.h" to d header module.
                                                                                        >     7  //                                       2004/08/19 k.inaba
                                                                                        >     8  //----------------------------------------------------------------
                                                                                        >     9  
                                                                                        >    10  //       VVV   original copyright notice of "bzlib.h" VVV       //
                                                                                        >    11  /*--
                                                                                        >    12    This file is a part of bzip2 and/or libbzip2, a program and
                                                                                        >    13    library for lossless, block-sorting data compression.
                                                                                        >    14  
                                                                                        >    15    Copyright (C) 1996-2002 Julian R Seward.  All rights reserved.
                                                                                        >    16  
                                                                                        >    17    Redistribution and use in source and binary forms, with or without
                                                                                        >    18    modification, are permitted provided that the following conditions
                                                                                        >    19    are met:
                                                                                        >    20  
                                                                                        >    21    1. Redistributions of source code must retain the above copyright
                                                                                        >    22       notice, this list of conditions and the following disclaimer.
                                                                                        >    23  
                                                                                        >    24    2. The origin of this software must not be misrepresented; you must
                                                                                        >    25       not claim that you wrote the original software.  If you use this
                                                                                        >    26       software in a product, an acknowledgment in the product
                                                                                        >    27       documentation would be appreciated but is not required.
                                                                                        >    28  
                                                                                        >    29    3. Altered source versions must be plainly marked as such, and must
                                                                                        >    30       not be misrepresented as being the original software.
                                                                                        >    31  
                                                                                        >    32    4. The name of the author may not be used to endorse or promote
                                                                                        >    33       products derived from this software without specific prior written
                                                                                        >    34       permission.
                                                                                        >    35  
                                                                                        >    36    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
                                                                                        >    37    OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
                                                                                        >    38    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                                                                                        >    39    ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
                                                                                        >    40    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                                                                                        >    41    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
                                                                                        >    42    GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                                                                                        >    43    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
                                                                                        >    44    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
                                                                                        >    45    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
                                                                                        >    46    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                                                                                        >    47  
                                                                                        >    48    Julian Seward, Cambridge, UK.
                                                                                        >    49    jseward@acm.org
                                                                                        >    50    bzip2/libbzip2 version 1.0 of 21 March 2000
                                                                                        >    51  
                                                                                        >    52    This program is based on (at least) the work of:
                                                                                        >    53       Mike Burrows
                                                                                        >    54       David Wheeler
                                                                                        >    55       Peter Fenwick
                                                                                        >    56       Alistair Moffat
                                                                                        >    57       Radford Neal
                                                                                        >    58       Ian H. Witten
                                                                                        >    59       Robert Sedgewick
                                                                                        >    60       Jon L. Bentley
                                                                                        >    61  
                                                                                        >    62    For more information on these sources, see the manual.
                                                                                        >    63  --*/
                                                                                        >    64  
                                                                                        >    65  enum
                                                                                        >    66  {
                                                                                        >    67          BZ_RUN    = 0,
                                                                                        >    68          BZ_FLUSH  = 1,
                                                                                        >    69          BZ_FINISH = 2,
                                                                                        >    70  }
                                                                                        >    71  
                                                                                        >    72  enum
                                                                                        >    73  {
                                                                                        >    74          BZ_OK                = 0,
                                                                                        >    75          BZ_RUN_OK            = 1,
                                                                                        >    76          BZ_FLUSH_OK          = 2,
                                                                                        >    77          BZ_FINISH_OK         = 3,
                                                                                        >    78          BZ_STREAM_END        = 4,
                                                                                        >    79          BZ_SEQUENCE_ERROR    = (-1),
                                                                                        >    80          BZ_PARAM_ERROR       = (-2),
                                                                                        >    81          BZ_MEM_ERROR         = (-3),
                                                                                        >    82          BZ_DATA_ERROR        = (-4),
                                                                                        >    83          BZ_DATA_ERROR_MAGIC  = (-5),
                                                                                        >    84          BZ_IO_ERROR          = (-6),
                                                                                        >    85          BZ_UNEXPECTED_EOF    = (-7),
                                                                                        >    86          BZ_OUTBUFF_FULL      = (-8),
                                                                                        >    87          BZ_CONFIG_ERROR      = (-9),
                                                                                        >    88  }
                                                                                        >    89  
                                                                                        >    90  struct bz_stream
                                                                                        >    91  {
                                                                                        >    92      char *next_in;
                                                                                        >    93      uint avail_in;
                                                                                        >    94      uint total_in_lo32;
                                                                                        >    95      uint total_in_hi32;
                                                                                        >    96  
                                                                                        >    97      char *next_out;
                                                                                        >    98      uint avail_out;
                                                                                        >    99      uint total_out_lo32;
                                                                                        >   100      uint total_out_hi32;
                                                                                        >   101  
                                                                                        >   102      void *state;
                                                                                        >   103  
                                                                                        >   104      void *(*bzalloc)(void *,int,int);
                                                                                        >   105      void (*bzfree)(void *,void *);
                                                                                        >   106      void *opaque;
                                                                                        >   107  }
                                                                                        >   108  
                                                                                        >   109  extern(Windows)
                                                                                        >   110  {
                                                                                        >   111  /*-- Core (low-level) library functions --*/
                                                                                        >   112  
                                                                                        >   113          int BZ2_bzCompressInit(
                                                                                        >   114                bz_stream* strm,
                                                                                        >   115                int        blockSize100k,
                                                                                        >   116                int        verbosity,
                                                                                        >   117                int        workFactor
                                                                                        >   118             );
                                                                                        >   119  
                                                                                        >   120          int BZ2_bzCompress(
                                                                                        >   121                bz_stream* strm,
                                                                                        >   122                int action
                                                                                        >   123             );
                                                                                        >   124  
                                                                                        >   125          int BZ2_bzCompressEnd(
                                                                                        >   126                bz_stream* strm
                                                                                        >   127             );
                                                                                        >   128  
                                                                                        >   129          int BZ2_bzDecompressInit(
                                                                                        >   130                bz_stream *strm,
                                                                                        >   131                int       verbosity,
                                                                                        >   132                int       small
                                                                                        >   133             );
                                                                                        >   134  
                                                                                        >   135          int BZ2_bzDecompress(
                                                                                        >   136                bz_stream* strm
                                                                                        >   137             );
                                                                                        >   138  
                                                                                        >   139          int BZ2_bzDecompressEnd(
                                                                                        >   140                bz_stream *strm
                                                                                        >   141             );
                                                                                        >   142  
                                                                                        >   143  /*-- High(er) level library functions --*/
                                                                                        >   144  
                                                                                        >   145          enum { BZ_MAX_UNUSED = 5000 }
                                                                                        >   146          alias void BZFILE;
                                                                                        >   147  
                                                                                        >   148          BZFILE* BZ2_bzReadOpen(
                                                                                        >   149                int*  bzerror,
                                                                                        >   150                FILE* f,
                                                                                        >   151                int   verbosity,
                                                                                        >   152                int   small,
                                                                                        >   153                void* unused,
                                                                                        >   154                int   nUnused
                                                                                        >   155             );
                                                                                        >   156  
                                                                                        >   157          void BZ2_bzReadClose(
                                                                                        >   158                int*    bzerror,
                                                                                        >   159                BZFILE* b
                                                                                        >   160             );
                                                                                        >   161  
                                                                                        >   162          void BZ2_bzReadGetUnused(
                                                                                        >   163                int*    bzerror,
                                                                                        >   164                BZFILE* b,
                                                                                        >   165                void**  unused,
                                                                                        >   166                int*    nUnused
                                                                                        >   167             );
                                                                                        >   168  
                                                                                        >   169          int BZ2_bzRead(
                                                                                        >   170                int*    bzerror,
                                                                                        >   171                BZFILE* b,
                                                                                        >   172                void*   buf,
                                                                                        >   173                int     len
                                                                                        >   174             );
                                                                                        >   175  
                                                                                        >   176          BZFILE* BZ2_bzWriteOpen(
                                                                                        >   177                int*  bzerror,
                                                                                        >   178                FILE* f,
                                                                                        >   179                int   blockSize100k,
                                                                                        >   180                int   verbosity,
                                                                                        >   181                int   workFactor
                                                                                        >   182             );
                                                                                        >   183  
                                                                                        >   184          void BZ2_bzWrite(
                                                                                        >   185                int*    bzerror,
                                                                                        >   186                BZFILE* b,
                                                                                        >   187                void*   buf,
                                                                                        >   188                int     len
                                                                                        >   189             );
                                                                                        >   190  
                                                                                        >   191          void BZ2_bzWriteClose(
                                                                                        >   192                int*          bzerror,
                                                                                        >   193                BZFILE*       b,
                                                                                        >   194                int           abandon,
                                                                                        >   195                uint*         nbytes_in,
                                                                                        >   196                uint*         nbytes_out
                                                                                        >   197             );
                                                                                        >   198  
                                                                                        >   199          void BZ2_bzWriteClose64(
                                                                                        >   200                int*          bzerror,
                                                                                        >   201                BZFILE*       b,
                                                                                        >   202                int           abandon,
                                                                                        >   203                uint*         nbytes_in_lo32,
                                                                                        >   204                uint*         nbytes_in_hi32,
                                                                                        >   205                uint*         nbytes_out_lo32,
                                                                                        >   206                uint*         nbytes_out_hi32
                                                                                        >   207             );
                                                                                        >   208  
                                                                                        >   209  /*-- Utility functions --*/
                                                                                        >   210  
                                                                                        >   211          int BZ2_bzBuffToBuffCompress(
                                                                                        >   212                char*         dest,
                                                                                        >   213                uint*         destLen,
                                                                                        >   214                char*         source,
                                                                                        >   215                uint          sourceLen,
                                                                                        >   216                int           blockSize100k,
                                                                                        >   217                int           verbosity,
                                                                                        >   218                int           workFactor
                                                                                        >   219             );
                                                                                        >   220  
                                                                                        >   221          int BZ2_bzBuffToBuffDecompress(
                                                                                        >   222                char*         dest,
                                                                                        >   223                uint*         destLen,
                                                                                        >   224                char*         source,
                                                                                        >   225                int           sourceLen,
                                                                                        >   226                int           small,
                                                                                        >   227                int           verbosity
                                                                                        >   228             );
                                                                                        >   229  
                                                                                        >   230  /*--
                                                                                        >   231     Code contributed by Yoshioka Tsuneo
                                                                                        >   232     (QWF00133@niftyserve.or.jp/tsuneo-y@is.aist-nara.ac.jp),
                                                                                        >   233     to support better zlib compatibility.
                                                                                        >   234     This code is not _officially_ part of libbzip2 (yet);
                                                                                        >   235     I haven't tested it, documented it, or considered the
                                                                                        >   236     threading-safeness of it.
                                                                                        >   237     If this code breaks, please contact both Yoshioka and me.
                                                                                        >   238  --*/
                                                                                        >   239  
                                                                                        >   240          char* BZ2_bzlibVersion(
                                                                                        >   241             );
                                                                                        >   242  
                                                                                        >   243          BZFILE * BZ2_bzopen(
                                                                                        >   244                char *path,
                                                                                        >   245                char *mode
                                                                                        >   246             );
                                                                                        >   247  
                                                                                        >   248          BZFILE * BZ2_bzdopen(
                                                                                        >   249                int        fd,
                                                                                        >   250                char *mode
                                                                                        >   251             );
                                                                                        >   252  
                                                                                        >   253          int BZ2_bzread(
                                                                                        >   254                BZFILE* b,
                                                                                        >   255                void* buf,
                                                                                        >   256                int len
                                                                                        >   257             );
                                                                                        >   258  
                                                                                        >   259          int BZ2_bzwrite(
                                                                                        >   260                BZFILE* b,
                                                                                        >   261                void*   buf,
                                                                                        >   262                int     len
                                                                                        >   263             );
                                                                                        >   264  
                                                                                        >   265          int BZ2_bzflush(
                                                                                        >   266                BZFILE* b
                                                                                        >   267             );
                                                                                        >   268  
                                                                                        >   269          void BZ2_bzclose(
                                                                                        >   270                BZFILE* b
                                                                                        >   271             );
                                                                                        >   272  
                                                                                        >   273          char * BZ2_bzerror(
                                                                                        >   274                BZFILE *b,
                                                                                        >   275                int    *errnum
                                                                                        >   276             );
                                                                                        >   277  }

Added src/libbz2/libbz2.lib version [0e9d59d11e954835]

cannot compute difference between binary files

Added src/qbga32.d version [f1f9b8362f0839ce]

                                                                                        >     1  private import std.string;
                                                                                        >     2  private import std.file;
                                                                                        >     3  private import win32.ansi.windows;
                                                                                        >     4  private import util;
                                                                                        >     5  private import windll;
                                                                                        >     6  private import bga_melter;
                                                                                        >     7  private import qbga_gui;
                                                                                        >     8  
                                                                                        >     9  //----------------------------------------------------------------
                                                                                        >    10  // 縺翫″縺ｾ繧翫�ｮDLL蛻晄悄蛹悶Ν繝ｼ繝√Φ
                                                                                        >    11  //----------------------------------------------------------------
                                                                                        >    12  
                                                                                        >    13  HINSTANCE g_hinst;
                                                                                        >    14  
                                                                                        >    15  extern(C)
                                                                                        >    16  {
                                                                                        >    17          void gc_init();
                                                                                        >    18          void gc_term();
                                                                                        >    19          void _minit();
                                                                                        >    20          void _moduleCtor();
                                                                                        >    21          void _moduleDtor();
                                                                                        >    22          void _moduleUnitTests();
                                                                                        >    23  }
                                                                                        >    24  
                                                                                        >    25  extern (Windows)
                                                                                        >    26  BOOL DllMain( HINSTANCE inst, ULONG reason, void* reserved )
                                                                                        >    27  {
                                                                                        >    28          switch( reason )
                                                                                        >    29          {
                                                                                        >    30          case DLL_PROCESS_ATTACH:
                                                                                        >    31                  g_hinst = inst;
                                                                                        >    32                  gc_init();          // GC蛻晄悄蛹�
                                                                                        >    33                  _minit();           // 繝｢繧ｸ繝･繝ｼ繝ｫ繝ｪ繧ｹ繝亥�晄悄蛹�
                                                                                        >    34                  _moduleCtor();      // 繝｢繧ｸ繝･繝ｼ繝ｫ繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ螳溯｡�
                                                                                        >    35                  _moduleUnitTests(); // 蜊倅ｽ薙ユ繧ｹ繝亥ｮ溯｡�
                                                                                        >    36                  if( g_orig_dll is null )
                                                                                        >    37                          return false;
                                                                                        >    38                  break;
                                                                                        >    39  
                                                                                        >    40          case DLL_PROCESS_DETACH:
                                                                                        >    41                  _moduleDtor();
                                                                                        >    42                  gc_term();     // GC邨ゆｺ�
                                                                                        >    43                  break;
                                                                                        >    44  
                                                                                        >    45          default:
                                                                                        >    46          case DLL_THREAD_ATTACH:
                                                                                        >    47          case DLL_THREAD_DETACH:
                                                                                        >    48                  break;
                                                                                        >    49          }
                                                                                        >    50          return true;
                                                                                        >    51  }
                                                                                        >    52  
                                                                                        >    53  //----------------------------------------------------------------
                                                                                        >    54  // API霆｢騾∝�ｦ逅�
                                                                                        >    55  //----------------------------------------------------------------
                                                                                        >    56  
                                                                                        >    57  WinDLL g_orig_dll = null;
                                                                                        >    58  UINT   WM_ARCEXTRACT;
                                                                                        >    59  
                                                                                        >    60  static this()
                                                                                        >    61  {
                                                                                        >    62          g_orig_dll = WinDLL.load( "_Bga32.DLL" );
                                                                                        >    63          WM_ARCEXTRACT = RegisterWindowMessage("wm_arcextract");
                                                                                        >    64  }
                                                                                        >    65  
                                                                                        >    66  static ~this()
                                                                                        >    67  {
                                                                                        >    68          g_orig_dll.close();
                                                                                        >    69  }
                                                                                        >    70  
                                                                                        >    71  template api(FnT)
                                                                                        >    72  {
                                                                                        >    73          FnT api( char[] name )
                                                                                        >    74          {
                                                                                        >    75                  return g_orig_dll.get_api!(FnT)( name );
                                                                                        >    76          }
                                                                                        >    77  }
                                                                                        >    78  
                                                                                        >    79  //----------------------------------------------------------------
                                                                                        >    80  // 邨ｱ蜷医い繝ｼ繧ｫ繧､繝植PI�ｼ夊ｻ｢騾�
                                                                                        >    81  //----------------------------------------------------------------
                                                                                        >    82  
                                                                                        >    83  extern(Windows)
                                                                                        >    84  {
                                                                                        >    85          int Bga( HWND a, char* b, char* c, DWORD d )
                                                                                        >    86          {
                                                                                        >    87                  int r = Bga_impl( a, toString(b) );
                                                                                        >    88                  if( r < 0 ) // 縺薙�ｮ繝�繝溘�ｼDLL縺ｧ縺ｯ蜃ｦ逅�縺ｧ縺阪↑縺�繧ｳ繝槭Φ繝峨□縺｣縺�譎�
                                                                                        >    89                          return api!(typeof(&Bga))("Bga")(a,b,c,d);
                                                                                        >    90                  return r;
                                                                                        >    91          }
                                                                                        >    92  
                                                                                        >    93          WORD QBgaGetVersion()
                                                                                        >    94          {
                                                                                        >    95                  return 4;
                                                                                        >    96          }
                                                                                        >    97  
                                                                                        >    98          WORD BgaGetVersion()
                                                                                        >    99          {
                                                                                        >   100                  return api!(typeof(&BgaGetVersion))("BgaGetVersion")();
                                                                                        >   101          }
                                                                                        >   102  
                                                                                        >   103          BOOL BgaGetRunning()
                                                                                        >   104          {
                                                                                        >   105                  return api!(typeof(&BgaGetRunning))("BgaGetRunning")();
                                                                                        >   106          }
                                                                                        >   107  
                                                                                        >   108          BOOL BgaCheckArchive( char* a, int b )
                                                                                        >   109          {
                                                                                        >   110                  return api!(typeof(&BgaCheckArchive))("BgaCheckArchive")(a,b);
                                                                                        >   111          }
                                                                                        >   112  
                                                                                        >   113          BOOL BgaConfigDialog( HWND a, char* b, int c )
                                                                                        >   114          {
                                                                                        >   115                  return api!(typeof(&BgaConfigDialog))("BgaConfigDialog")(a,b,c);
                                                                                        >   116          }
                                                                                        >   117  
                                                                                        >   118          int BgaGetFileCount( char* a )
                                                                                        >   119          {
                                                                                        >   120                  return api!(typeof(&BgaGetFileCount))("BgaGetFileCount")(a);
                                                                                        >   121          }
                                                                                        >   122  
                                                                                        >   123          BOOL BgaQueryFunctionList( int a )
                                                                                        >   124          {
                                                                                        >   125                  return api!(typeof(&BgaQueryFunctionList))("BgaQueryFunctionList
                                                                                        >   126          }
                                                                                        >   127  
                                                                                        >   128          alias void* HARC;
                                                                                        >   129          HARC BgaOpenArchive( HWND a, char* b, DWORD c )
                                                                                        >   130          {
                                                                                        >   131                  return api!(typeof(&BgaOpenArchive))("BgaOpenArchive")(a,b,c);
                                                                                        >   132          }
                                                                                        >   133  
                                                                                        >   134          int BgaCloseArchive( HARC a )
                                                                                        >   135          {
                                                                                        >   136                  return api!(typeof(&BgaCloseArchive))("BgaCloseArchive")(a);
                                                                                        >   137          }
                                                                                        >   138  
                                                                                        >   139          alias void* LPINDIVIDUALINFO;
                                                                                        >   140          int BgaFindFirst( HARC a, char* b, LPINDIVIDUALINFO c )
                                                                                        >   141          {
                                                                                        >   142                  return api!(typeof(&BgaFindFirst))("BgaFindFirst")(a,b,c);
                                                                                        >   143          }
                                                                                        >   144  
                                                                                        >   145          int BgaFindNext( HARC a, LPINDIVIDUALINFO b )
                                                                                        >   146          {
                                                                                        >   147                  return api!(typeof(&BgaFindNext))("BgaFindNext")(a,b);
                                                                                        >   148          }
                                                                                        >   149  
                                                                                        >   150          DWORD BgaGetArcOriginalSize( HARC a )
                                                                                        >   151          {
                                                                                        >   152                  return api!(typeof(&BgaGetArcOriginalSize))("BgaGetArcOriginalSi
                                                                                        >   153          }
                                                                                        >   154  
                                                                                        >   155          DWORD BgaGetArcCompressedSize( HARC a )
                                                                                        >   156          {
                                                                                        >   157                  return api!(typeof(&BgaGetArcCompressedSize))("BgaGetArcCompress
                                                                                        >   158          }
                                                                                        >   159  
                                                                                        >   160          WORD BgaGetArcRatio( HARC a )
                                                                                        >   161          {
                                                                                        >   162                  return api!(typeof(&BgaGetArcRatio))("BgaGetArcRatio")(a);
                                                                                        >   163          }
                                                                                        >   164  
                                                                                        >   165          BOOL BgaSetOwnerWindow( HWND a )
                                                                                        >   166          {
                                                                                        >   167                  BOOL r = api!(typeof(&BgaSetOwnerWindow))("BgaSetOwnerWindow")(a
                                                                                        >   168                  if( r ) BgaSetOwnerWindow_impl(a);
                                                                                        >   169                  return r;
                                                                                        >   170          }
                                                                                        >   171  
                                                                                        >   172          BOOL BgaClearOwnerWindow()
                                                                                        >   173          {
                                                                                        >   174                  BOOL r = api!(typeof(&BgaClearOwnerWindow))("BgaClearOwnerWindow
                                                                                        >   175                  BgaClearOwnerWindow_impl();
                                                                                        >   176                  return r;
                                                                                        >   177          }
                                                                                        >   178  
                                                                                        >   179          alias BOOL function(HWND,UINT,UINT,EXTRACTINGINFOEX*) ARCHIVERPROC;
                                                                                        >   180          BOOL BgaSetOwnerWindowEx( HWND a, ARCHIVERPROC* b )
                                                                                        >   181          {
                                                                                        >   182                  BOOL r = api!(typeof(&BgaSetOwnerWindowEx))("BgaSetOwnerWindowEx
                                                                                        >   183                  if( r ) BgaSetOwnerWindowEx_impl(a,b);
                                                                                        >   184                  return r;
                                                                                        >   185          }
                                                                                        >   186  
                                                                                        >   187          BOOL BgaKillOwnerWindowEx( HWND a )
                                                                                        >   188          {
                                                                                        >   189                  BOOL r = api!(typeof(&BgaKillOwnerWindowEx))("BgaKillOwnerWindow
                                                                                        >   190                  BgaClearOwnerWindow_impl();
                                                                                        >   191                  return r;
                                                                                        >   192          }
                                                                                        >   193  
                                                                                        >   194          alias void* UNLHA_WND_ENUMMEMBPROC;
                                                                                        >   195          BOOL BgaSetEnumMembersProc( UNLHA_WND_ENUMMEMBPROC a )
                                                                                        >   196          {
                                                                                        >   197                  return api!(typeof(&BgaSetEnumMembersProc))("BgaSetEnumMembersPr
                                                                                        >   198          }
                                                                                        >   199  
                                                                                        >   200          BOOL BgaClearEnumMembersProc()
                                                                                        >   201          {
                                                                                        >   202                  return api!(typeof(&BgaClearEnumMembersProc))("BgaClearEnumMembe
                                                                                        >   203          }
                                                                                        >   204  }
                                                                                        >   205  
                                                                                        >   206  //----------------------------------------------------------------
                                                                                        >   207  // 邨ｱ蜷医い繝ｼ繧ｫ繧､繝植PI�ｼ壼ｮ溯｣�( Bga )
                                                                                        >   208  //----------------------------------------------------------------
                                                                                        >   209  
                                                                                        >   210  int Bga_impl( HWND wnd, char[] cmd_str )
                                                                                        >   211  {
                                                                                        >   212          enum { UNSUPPORTED = -1 }
                                                                                        >   213  
                                                                                        >   214          //
                                                                                        >   215          // 繧ｳ繝槭Φ繝峨Λ繧､繝ｳ隗｣譫�
                                                                                        >   216          //
                                                                                        >   217          char[][] cmd = cmd_parse(cmd_str);
                                                                                        >   218  
                                                                                        >   219          // x莉･螟悶�ｮ繧ｳ繝槭Φ繝峨�ｯ謇ｱ繧上↑縺�縺ｧ譛ｬ迚ｩDLL縺ｫ蝗槭＠縺ｾ縺吶�よｳｨ諢冗せ縺ｨ縺励※�ｼ�
                                                                                        >   220          //  > command 縺ｯ繧ｳ繝槭Φ繝峨Λ繧､繝ｳ縺ｮ譛�蛻昴�ｮ蠑墓焚縺ｨ縺励※縺上□縺輔＞縲ゅ↑縺翫�…ommand 繧堤怐逡･
                                                                                        >   221          //  > 縺励◆蝣ｴ蜷医�ｯ 'x' command 縺梧欠螳壹＆繧後◆繧ゅ�ｮ縺ｨ縺ｿ縺ｪ縺励∪縺吶��
                                                                                        >   222          if( cmd.length == 0 )
                                                                                        >   223                  return UNSUPPORTED;
                                                                                        >   224          if( cmd[0].length == 1 )
                                                                                        >   225          {
                                                                                        >   226                  if( 0 <= find("adjlmnstvADJLMNSTV", cmd[0][0]) )
                                                                                        >   227                          return UNSUPPORTED;
                                                                                        >   228                  if( cmd[0][0]=='x' || cmd[0][0]=='X' )
                                                                                        >   229                          cmd = cmd[1 .. length];
                                                                                        >   230          }
                                                                                        >   231  
                                                                                        >   232                  // 窶ｻ 縺薙�ｮ譎らせ縺ｧ縲…md縺ｫ縺ｯcommand繧帝勁縺�縺滓ｮ九ｊ縺ｮ蠑墓焚縺悟�･縺｣�※縺�繧九�ｯ縺�
                                                                                        >   233  
                                                                                        >   234          //
                                                                                        >   235          // 繧ｹ繧､繝�繝∬ｧ｣譫舌�∝ｼ墓焚隗｣譫�
                                                                                        >   236          //
                                                                                        >   237          bool all_attrs       = false; // -a
                                                                                        >   238          bool silent          = false; // -i
                                                                                        >   239          bool ignore_dir      = false; // -j
                                                                                        >   240          bool newfile_only    = false; // -n
                                                                                        >   241          bool force_overwrite = false; // -o
                                                                                        >   242          bool recursive       = false; // -r
                                                                                        >   243          bool sanitize_path   = true;
                                                                                        >   244  
                                                                                        >   245          char[] arc_name = null;
                                                                                        >   246          char[] base_dir = null;
                                                                                        >   247          char[][] paths;
                                                                                        >   248  
                                                                                        >   249          foreach( char[] param ; cmd )
                                                                                        >   250                  if( param[0] == '-' )
                                                                                        >   251                          switch( param[1] )
                                                                                        >   252                          {
                                                                                        >   253                          case 'a','A': all_attrs       = true; break;
                                                                                        >   254                          case 'i','I': silent          = true; break;
                                                                                        >   255                          case 'j','J': ignore_dir      = true; break;
                                                                                        >   256                          case 'n','N': newfile_only    = true; break;
                                                                                        >   257                          case 'o','O': force_overwrite = true; break;
                                                                                        >   258                          case 'r','R': recursive       = true; break;
                                                                                        >   259                          default:  break;
                                                                                        >   260                          }
                                                                                        >   261                  else if( arc_name is null )
                                                                                        >   262                  {
                                                                                        >   263                          arc_name = param;
                                                                                        >   264                  }
                                                                                        >   265                  else if( base_dir is null )
                                                                                        >   266                  {
                                                                                        >   267                          if( lastChar(param) == '\\' )
                                                                                        >   268                                  base_dir = param;
                                                                                        >   269                          else {
                                                                                        >   270                                  base_dir.length = GetCurrentDirectory(0,null)+1;
                                                                                        >   271                                  GetCurrentDirectory(base_dir.length, base_dir);
                                                                                        >   272                                  base_dir.length = strlen(base_dir);
                                                                                        >   273                                  if( lastChar(base_dir) != '\\' )
                                                                                        >   274                                          base_dir ~= '\\';
                                                                                        >   275                          }
                                                                                        >   276                  }
                                                                                        >   277                  else
                                                                                        >   278                          paths ~= param;
                                                                                        >   279  
                                                                                        >   280          //
                                                                                        >   281          // 螻暮幕蜃ｦ逅�縺ｫGo!
                                                                                        >   282          //
                                                                                        >   283          ProgressDlg dlg = null;
                                                                                        >   284          if( !do_ownerwnd_proc( OP_ARC_BEGIN, null, 0, arc_name ) )
                                                                                        >   285                  return 0x8020;
                                                                                        >   286  
                                                                                        >   287          try
                                                                                        >   288          {
                                                                                        >   289                  if( !silent && g_handler is null ) // -i / OwnerWndProc
                                                                                        >   290                  {
                                                                                        >   291                          dlg = new ProgressDlg(
                                                                                        >   292                                  cast(DLGTEMPLATE*) g_orig_dll.load_dialog("#2025
                                                                                        >   293                          dlg.set_arcname(arc_name);
                                                                                        >   294                  }
                                                                                        >   295  
                                                                                        >   296                  char[]    src_fname; // OwnerWndProc髢｢菫�
                                                                                        >   297                  BgaHeader cur_hdr;   // OwnerWndProc髢｢菫�
                                                                                        >   298  
                                                                                        >   299                  BgaAnswer handler( inout BgaHeader hdr )
                                                                                        >   300                  {
                                                                                        >   301                          src_fname = hdr.fname;
                                                                                        >   302                          process_messages();
                                                                                        >   303  
                                                                                        >   304                          // paths
                                                                                        >   305                          if( paths.length > 0 )
                                                                                        >   306                          {
                                                                                        >   307                                  char[] fname = // -r
                                                                                        >   308                                          (recursive ? hdr.fname[hdr.dir_name_len.
                                                                                        >   309                                                     : hdr.fname);
                                                                                        >   310                                  foreach( char[] w ; paths )
                                                                                        >   311                                          if( wild_match( w, fname ) )
                                                                                        >   312                                                  goto ok;
                                                                                        >   313                                  return BgaAnswer.SkipIt;
                                                                                        >   314                          ok:;
                                                                                        >   315                          }
                                                                                        >   316                          // -a
                                                                                        >   317                          if( !all_attrs && (hdr.attrib&6) )
                                                                                        >   318                                  return BgaAnswer.SkipIt;
                                                                                        >   319                          // dialog
                                                                                        >   320                          if( dlg )
                                                                                        >   321                                  if( dlg.closed )
                                                                                        >   322                                          return BgaAnswer.Abort;
                                                                                        >   323                                  else
                                                                                        >   324                                          dlg.set_filename( hdr.fname[hdr.dir_name
                                                                                        >   325                          // -j
                                                                                        >   326                          if( ignore_dir )
                                                                                        >   327                                  hdr.fname = hdr.fname[hdr.dir_name_len .. length
                                                                                        >   328                          // sanitize
                                                                                        >   329                          if( sanitize_path )
                                                                                        >   330                                  hdr.fname = check_path(hdr.fname);
                                                                                        >   331                          // base_dir
                                                                                        >   332                          hdr.fname = base_dir ~ hdr.fname;
                                                                                        >   333                          // -o
                                                                                        >   334                          if( !force_overwrite )
                                                                                        >   335                                  try {
                                                                                        >   336                                  if( std.file.exists(hdr.fname) && std.file.isfil
                                                                                        >   337                                          // -n
                                                                                        >   338                                          if( newfile_only )
                                                                                        >   339                                          {
                                                                                        >   340                                                  if( newer_than(hdr.date,hdr.time
                                                                                        >   341                                                          return BgaAnswer.SkipIt;
                                                                                        >   342                                          }
                                                                                        >   343                                          else
                                                                                        >   344                                          {
                                                                                        >   345                                                  int r = MessageBox( dlg?dlg.hwnd
                                                                                        >   346                                                          toStringz("Overwrite "~h
                                                                                        >   347                                                          "QBga32.dll", MB_YESNOCA
                                                                                        >   348                                                  if( r == IDNO )     return BgaAn
                                                                                        >   349                                                  if( r == IDCANCEL ) return BgaAn
                                                                                        >   350                                          }
                                                                                        >   351                                  } catch {}
                                                                                        >   352  
                                                                                        >   353                          cur_hdr = hdr;
                                                                                        >   354                          if( !do_ownerwnd_proc( OP_FILE_BEGIN, &cur_hdr, 0, src_f
                                                                                        >   355                                  return BgaAnswer.Abort;
                                                                                        >   356                          return BgaAnswer.MeltIt;
                                                                                        >   357                  }
                                                                                        >   358  
                                                                                        >   359                  BgaAnswer progress_handler( int cur, int max )
                                                                                        >   360                  {
                                                                                        >   361                          process_messages();
                                                                                        >   362                          if( dlg )
                                                                                        >   363                                  if( dlg.closed )
                                                                                        >   364                                          return BgaAnswer.Abort;
                                                                                        >   365                                  else
                                                                                        >   366                                          dlg.set_pos( cast(real)(cur)/max );
                                                                                        >   367                          if( !do_ownerwnd_proc( OP_FILE_MIDDLE, &cur_hdr, cur, sr
                                                                                        >   368                                  return BgaAnswer.Abort;
                                                                                        >   369                          return BgaAnswer.MeltIt;
                                                                                        >   370                  }
                                                                                        >   371  
                                                                                        >   372                  (new BgaMelter(arc_name)).start(&handler,&progress_handler);
                                                                                        >   373          }
                                                                                        >   374          catch( BgaMelterError e )
                                                                                        >   375          {
                                                                                        >   376                  return e.errcode;
                                                                                        >   377          }
                                                                                        >   378          finally
                                                                                        >   379          {
                                                                                        >   380                  do_ownerwnd_proc( OP_ARC_END, null, 0, arc_name );
                                                                                        >   381                  if( dlg )
                                                                                        >   382                          dlg.close();
                                                                                        >   383          }
                                                                                        >   384          return 0;
                                                                                        >   385  }
                                                                                        >   386  
                                                                                        >   387  //----------------------------------------------------------------
                                                                                        >   388  // 邨ｱ蜷医い繝ｼ繧ｫ繧､繝植PI�ｼ壼ｮ溯｣�( SetOwnerWindow )
                                                                                        >   389  //----------------------------------------------------------------
                                                                                        >   390  
                                                                                        >   391  align(1) struct EXTRACTINGINFO
                                                                                        >   392  {
                                                                                        >   393          DWORD   dwFileSize;
                                                                                        >   394          DWORD   dwWriteSize;
                                                                                        >   395          char    szSourceFileName[512 + 1];
                                                                                        >   396          char    dummy1[3];
                                                                                        >   397          char    szDestFileName[512 + 1];
                                                                                        >   398          char    dummy[3];
                                                                                        >   399  }
                                                                                        >   400  align(1) struct EXTRACTINGINFOEX
                                                                                        >   401  {
                                                                                        >   402          EXTRACTINGINFO exinfo;
                                                                                        >   403          DWORD dwCompressedSize;
                                                                                        >   404          DWORD dwCRC;
                                                                                        >   405          UINT  uOSType;
                                                                                        >   406          WORD  wRatio;
                                                                                        >   407          WORD  wDate;
                                                                                        >   408          WORD  wTime;
                                                                                        >   409          char  szAttribute[8];
                                                                                        >   410          char  szMode[8];
                                                                                        >   411  }
                                                                                        >   412  
                                                                                        >   413  HWND g_owner_window;
                                                                                        >   414  extern(Windows) BOOL function(HWND,UINT,UINT,EXTRACTINGINFOEX*) g_handler;
                                                                                        >   415  extern(Windows) BOOL noex_handler( HWND w,UINT m,UINT s, EXTRACTINGINFOEX* e )
                                                                                        >   416  {
                                                                                        >   417          return !SendMessage( w, m, s, cast(LPARAM) &e.exinfo );
                                                                                        >   418  }
                                                                                        >   419  
                                                                                        >   420  void BgaSetOwnerWindow_impl( HWND wnd )
                                                                                        >   421  {
                                                                                        >   422          g_owner_window = wnd;
                                                                                        >   423          g_handler      = &noex_handler;
                                                                                        >   424  }
                                                                                        >   425  
                                                                                        >   426  void BgaClearOwnerWindow_impl()
                                                                                        >   427  {
                                                                                        >   428          g_owner_window = null;
                                                                                        >   429          g_handler      = null;
                                                                                        >   430  }
                                                                                        >   431  
                                                                                        >   432  void BgaSetOwnerWindowEx_impl( HWND wnd, ARCHIVERPROC* proc )
                                                                                        >   433  {
                                                                                        >   434          g_owner_window = wnd;
                                                                                        >   435          g_handler      = *proc;
                                                                                        >   436  }
                                                                                        >   437  
                                                                                        >   438  enum { OP_FILE_BEGIN, OP_FILE_MIDDLE, OP_ARC_END, OP_ARC_BEGIN }
                                                                                        >   439  bool do_ownerwnd_proc( UINT uState, BgaHeader* hdr, int cur, char[] src_fname )
                                                                                        >   440  {
                                                                                        >   441          if( g_handler is null )
                                                                                        >   442                  return true;
                                                                                        >   443          EXTRACTINGINFOEX ex;
                                                                                        >   444          if( uState == OP_ARC_BEGIN || uState == OP_ARC_END )
                                                                                        >   445          {
                                                                                        >   446                  lstrcpyn( ex.exinfo.szSourceFileName, toStringz(src_fname), 512 
                                                                                        >   447          }
                                                                                        >   448          else
                                                                                        >   449          {
                                                                                        >   450                  ex.exinfo.dwFileSize  = hdr.original_size;
                                                                                        >   451                  ex.exinfo.dwWriteSize = cur;
                                                                                        >   452                  lstrcpyn( ex.exinfo.szSourceFileName, toStringz(src_fname), 512 
                                                                                        >   453                  lstrcpyn( ex.exinfo.szDestFileName, toStringz(hdr.fname), 512 );
                                                                                        >   454                  ex.dwCompressedSize = hdr.compressed_size;
                                                                                        >   455                  ex.wRatio = cast(int)( (cast(real)hdr.compressed_size)/hdr.origi
                                                                                        >   456                  ex.wDate  = hdr.date;
                                                                                        >   457                  ex.wTime  = hdr.time;
                                                                                        >   458                  ex.szAttribute[0] = (hdr.attrib&32 ? 'A': '-');
                                                                                        >   459                  ex.szAttribute[1] = (hdr.attrib&1  ? 'R': '-');
                                                                                        >   460                  ex.szAttribute[2] = (hdr.attrib&2  ? 'H': '-');
                                                                                        >   461                  ex.szAttribute[3] = (hdr.attrib&4  ? 'S': '-');
                                                                                        >   462                  ex.szAttribute[4] = (hdr.attrib&16 ? 'D': '-');
                                                                                        >   463                  ex.szAttribute[5] = '\0';
                                                                                        >   464                  if( hdr.method[0]=='G' )
                                                                                        >   465                          lstrcpy(ex.szMode,"-gzip-");
                                                                                        >   466                  else
                                                                                        >   467                          lstrcpy(ex.szMode,"-bzip2-");
                                                                                        >   468          }
                                                                                        >   469  
                                                                                        >   470          return false != g_handler( g_owner_window, WM_ARCEXTRACT, uState, &ex );
                                                                                        >   471  }
                                                                                        >   472  
                                                                                        >   473  //----------------------------------------------------------------
                                                                                        >   474  // 繝代せ讀懈渊邉ｻ
                                                                                        >   475  //----------------------------------------------------------------
                                                                                        >   476  
                                                                                        >   477  alias std.c.windows.windows.IsDBCSLeadByte isDL;
                                                                                        >   478  char[] replace_yen( char[] s )
                                                                                        >   479  {
                                                                                        >   480          char[] ans;
                                                                                        >   481          int j=0;
                                                                                        >   482          for(int i=0; i!=s.length; i=i+(isDL(s[i])?2:1))
                                                                                        >   483                  if( s[i] == '\\' )
                                                                                        >   484                          ans~=s[j .. i], ans~='/', j=i+1;
                                                                                        >   485          ans ~= s[j .. length];
                                                                                        >   486          return ans;
                                                                                        >   487  }
                                                                                        >   488  
                                                                                        >   489  bool wild_match( char[] wild, char[] name )
                                                                                        >   490  {
                                                                                        >   491          bool wild_match_nopath( char[] w, char[] s )
                                                                                        >   492          {
                                                                                        >   493                  char[] advance( char[] s )
                                                                                        >   494                  {
                                                                                        >   495                          return s[(IsDBCSLeadByte(s[0])?2:1) .. length];
                                                                                        >   496                  }
                                                                                        >   497  
                                                                                        >   498                  while( w.length>0 )
                                                                                        >   499                          switch( w[0] )
                                                                                        >   500                          {
                                                                                        >   501                          case '?':
                                                                                        >   502                                  if( s.length==0 )
                                                                                        >   503                                          return false;
                                                                                        >   504                                  w = advance(w);
                                                                                        >   505                                  s = advance(s);
                                                                                        >   506                                  break;
                                                                                        >   507                          case '*':
                                                                                        >   508                                  if( s.length==0 )
                                                                                        >   509                                          return false;
                                                                                        >   510                                  w = advance(w);
                                                                                        >   511                                  if( w.length == 0 )
                                                                                        >   512                                          return true;
                                                                                        >   513                                  for( ; s.length!=0; s=advance(s) )
                                                                                        >   514                                          if( wild_match_nopath(w,s) )
                                                                                        >   515                                                  return true;
                                                                                        >   516                                  return false;
                                                                                        >   517                          default:
                                                                                        >   518                                  if( s.length==0 )
                                                                                        >   519                                          return false;
                                                                                        >   520                                  if( isDL(w[0]) )
                                                                                        >   521                                    { if( w[0..2] != s[0..2] ) return false; }
                                                                                        >   522                                  else
                                                                                        >   523                                    { if( w[0]    != s[0]    ) return false; }
                                                                                        >   524                                  w = advance(w);
                                                                                        >   525                                  s = advance(s);
                                                                                        >   526                                  break;
                                                                                        >   527                          }
                                                                                        >   528                  return s.length==0;
                                                                                        >   529          }
                                                                                        >   530  
                                                                                        >   531          if( wild=="" || wild=="*.*" || wild=="*" || wild=="**" )
                                                                                        >   532                  return true;
                                                                                        >   533  
                                                                                        >   534          char[][] wilds = split( replace_yen( tolower(wild) ), "/" );
                                                                                        >   535          char[][] names = split( replace_yen( tolower(name) ), "/" );
                                                                                        >   536  
                                                                                        >   537          if( wilds.length != names.length )
                                                                                        >   538                  return false;
                                                                                        >   539          for(int i=0; i!=wilds.length; ++i)
                                                                                        >   540                  if( wilds[i]!="*.*" && wilds[i]!="*" && wilds[i]!="**" )
                                                                                        >   541                          if( !wild_match_nopath( wilds[i], names[i] ) )
                                                                                        >   542                                  return false;
                                                                                        >   543          return true;
                                                                                        >   544  }
                                                                                        >   545  
                                                                                        >   546  char[] check_path( char[] path )
                                                                                        >   547  {
                                                                                        >   548          // C:\ ==> C_\
                                                                                        >   549          if( path.length>=2 && path[1]==':' )
                                                                                        >   550                  path = path.dup, path[1] = '_';
                                                                                        >   551  
                                                                                        >   552          // \\hoge ==> hoge
                                                                                        >   553          // /hoge  ==> hoge
                                                                                        >   554          while( path.length>0 && (path[0]=='\\'||path[0]=='/') )
                                                                                        >   555                  path = path[1..length];
                                                                                        >   556  
                                                                                        >   557          // .. ==> __
                                                                                        >   558          char[][] paths = split( replace_yen(path), "/" );
                                                                                        >   559          L1:
                                                                                        >   560          foreach( inout char[] pc ; paths )
                                                                                        >   561                  if( pc.length >= 2 )
                                                                                        >   562                  {
                                                                                        >   563                          foreach( char c ; pc )
                                                                                        >   564                                  if( c != '.' )
                                                                                        >   565                                          continue L1;
                                                                                        >   566                          pc = replace( pc, ".", "_" );
                                                                                        >   567                  }
                                                                                        >   568  
                                                                                        >   569          return join( paths, "\\" );
                                                                                        >   570  }
                                                                                        >   571  
                                                                                        >   572  
                                                                                        >   573  
                                                                                        >   574  //----------------------------------------------------------------
                                                                                        >   575  // 邁｡譏薙ユ繧ｹ繝茨ｼ�繧ゅ▲縺ｨ繝槭ず繝｡縺ｫ譖ｸ縺九↑縺阪ｃ窶ｦ
                                                                                        >   576  //----------------------------------------------------------------
                                                                                        >   577  
                                                                                        >   578  unittest
                                                                                        >   579  {
                                                                                        >   580          assert( check_path(`\\\\hoge\fuga`)==`hoge\fuga` );
                                                                                        >   581          assert( check_path(`/usr/local/`)==`usr\local\` );
                                                                                        >   582          assert( check_path(`..\abc def\...\.\g`)==`__\abc def\___\.\g` );
                                                                                        >   583          assert( wild_match(`a/b/c`,`A\b\C`) );
                                                                                        >   584          assert( wild_match(`a/*.*/a?x`,`A\hoge\Afx`) );
                                                                                        >   585          assert( Bga_impl(null,"a hoge") < 0 );
                                                                                        >   586  }

Added src/qbga32.def version [de6ead6df7563eae]

                                                                                        >     1  LIBRARY         QBGA32
                                                                                        >     2  DESCRIPTION     'Quasi Bga32 DLL'
                                                                                        >     3  
                                                                                        >     4  EXETYPE         NT
                                                                                        >     5  CODE        PRELOAD DISCARDABLE
                                                                                        >     6  DATA        PRELOAD SINGLE
                                                                                        >     7  
                                                                                        >     8  EXPORTS
                                                                                        >     9          Bga                                             @1
                                                                                        >    10          BgaGetVersion                   @2
                                                                                        >    11          BgaGetRunning                   @10
                                                                                        >    12          BgaCheckArchive                 @11
                                                                                        >    13          BgaConfigDialog                 @12
                                                                                        >    14          BgaGetFileCount                 @17
                                                                                        >    15          BgaQueryFunctionList    @18
                                                                                        >    16          BgaOpenArchive                  @21
                                                                                        >    17          BgaCloseArchive                 @22
                                                                                        >    18          BgaFindFirst                    @23
                                                                                        >    19          BgaFindNext                             @24
                                                                                        >    20          BgaGetArcOriginalSize   @33
                                                                                        >    21          BgaGetArcCompressedSize @34
                                                                                        >    22          BgaGetArcRatio                  @35
                                                                                        >    23          BgaSetOwnerWindow               @90
                                                                                        >    24          BgaClearOwnerWindow             @91
                                                                                        >    25          BgaSetOwnerWindowEx             @51
                                                                                        >    26          BgaKillOwnerWindowEx    @52
                                                                                        >    27          BgaSetEnumMembersProc   @99
                                                                                        >    28          BgaClearEnumMembersProc @100
                                                                                        >    29          QBgaGetVersion                  @178

Added src/qbga_gui.d version [983218cb4853f610]

                                                                                        >     1  �ｻｿprivate import std.string;
                                                                                        >     2  private import win32.ansi.windows;
                                                                                        >     3  private import win32.ansi.commctrl;
                                                                                        >     4  private import qbga32;
                                                                                        >     5  
                                                                                        >     6  void process_messages()
                                                                                        >     7  {
                                                                                        >     8          for( MSG msg; PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ); )
                                                                                        >     9          {
                                                                                        >    10                  TranslateMessage( &msg );
                                                                                        >    11                  DispatchMessage( &msg );
                                                                                        >    12          }
                                                                                        >    13  }
                                                                                        >    14  
                                                                                        >    15  // 螳溯｣�邯呎価(w
                                                                                        >    16  
                                                                                        >    17  class Dialog
                                                                                        >    18  {
                                                                                        >    19  public:
                                                                                        >    20          HWND hwnd()
                                                                                        >    21          {
                                                                                        >    22                  return handle;
                                                                                        >    23          }
                                                                                        >    24  
                                                                                        >    25  protected:
                                                                                        >    26          void on_init()   { MessageBox(null,"xxx",null,MB_OK); }
                                                                                        >    27          bool on_ok()     { return false; }
                                                                                        >    28          bool on_cancel() { return false; }
                                                                                        >    29          bool on_command( UINT cmd ) { return false; }
                                                                                        >    30          bool on_message( UINT msg, WPARAM wp, LPARAM lp ) { return false; }
                                                                                        >    31  
                                                                                        >    32          extern(Windows) private static BOOL
                                                                                        >    33                  static_dlg_proc( HWND dlg, UINT msg, WPARAM wp, LPARAM lp )
                                                                                        >    34          {
                                                                                        >    35                  if( msg == WM_INITDIALOG )
                                                                                        >    36                  {
                                                                                        >    37                          SetWindowLong( dlg, GWL_USERDATA, lp );
                                                                                        >    38  
                                                                                        >    39                          Dialog ptr = cast(Dialog) cast(Dialog*) lp;
                                                                                        >    40                          ptr.handle = dlg;
                                                                                        >    41                          ptr.on_init();
                                                                                        >    42                          return FALSE;
                                                                                        >    43                  }
                                                                                        >    44  
                                                                                        >    45                  Dialog ptr = cast(Dialog) cast(Dialog*) GetWindowLong(dlg,GWL_US
                                                                                        >    46                  if( ptr is null )
                                                                                        >    47                          return FALSE;
                                                                                        >    48  
                                                                                        >    49                  if( msg == WM_COMMAND )
                                                                                        >    50                          if( LOWORD(wp) == IDOK )
                                                                                        >    51                                  return ptr.on_ok();
                                                                                        >    52                          else if( LOWORD(wp) == IDCANCEL )
                                                                                        >    53                                  return ptr.on_cancel();
                                                                                        >    54                          else
                                                                                        >    55                                  return ptr.on_command( LOWORD(wp) );
                                                                                        >    56                  return ptr.on_message(msg,wp,lp);
                                                                                        >    57          }
                                                                                        >    58  
                                                                                        >    59  protected:
                                                                                        >    60          HWND handle;
                                                                                        >    61          void BeginModeless( DLGTEMPLATE* dlg_template, HWND parent )
                                                                                        >    62          {
                                                                                        >    63                  CreateDialogIndirectParam(
                                                                                        >    64                          g_hinst,
                                                                                        >    65                          dlg_template,
                                                                                        >    66                          parent,
                                                                                        >    67                          &static_dlg_proc,
                                                                                        >    68                          cast(LPARAM) cast(Dialog*) this
                                                                                        >    69                  );
                                                                                        >    70          }
                                                                                        >    71  
                                                                                        >    72          int BeginModal( DLGTEMPLATE* dlg_template, HWND parent )
                                                                                        >    73          {
                                                                                        >    74                  return DialogBoxIndirectParam(
                                                                                        >    75                          g_hinst,
                                                                                        >    76                          dlg_template,
                                                                                        >    77                          parent,
                                                                                        >    78                          &static_dlg_proc,
                                                                                        >    79                          cast(LPARAM) cast(Dialog*) this
                                                                                        >    80                  );
                                                                                        >    81          }
                                                                                        >    82  
                                                                                        >    83          void set_item_text( int ID, char[] str )
                                                                                        >    84          {
                                                                                        >    85                  SetDlgItemText( handle, ID, toStringz(str) );
                                                                                        >    86          }
                                                                                        >    87  
                                                                                        >    88          int send_item_msg( int ID, UINT msg, WPARAM wp=0, LPARAM lp=0 )
                                                                                        >    89          {
                                                                                        >    90                  return SendDlgItemMessage( handle, ID, msg, wp, lp );
                                                                                        >    91          }
                                                                                        >    92  }
                                                                                        >    93  
                                                                                        >    94  //------------------------------------------------------------
                                                                                        >    95  // #2025 [繝輔ぃ繧､繝ｫ繧呈桃菴應ｸｭ]
                                                                                        >    96  //   2006 : 譖ｸ蠎ｫ蜷�
                                                                                        >    97  //   2007 : 繝輔ぃ繧､繝ｫ蜷搾ｼ医ヱ繧ｹ辟｡縺暦ｼ�
                                                                                        >    98  //   2024 : 繝励Ο繧ｰ繝ｬ繧ｹ繝舌�ｼ
                                                                                        >    99  //      2 : 繧ｭ繝｣繝ｳ繧ｻ繝ｫ繝懊ち繝ｳ
                                                                                        >   100  //------------------------------------------------------------
                                                                                        >   101  
                                                                                        >   102  class ProgressDlg : Dialog
                                                                                        >   103  {
                                                                                        >   104          this( DLGTEMPLATE* dlg_template, HWND parent )
                                                                                        >   105          {
                                                                                        >   106                  BeginModeless( dlg_template, parent );
                                                                                        >   107          }
                                                                                        >   108  
                                                                                        >   109          void set_arcname ( char[] str ){ set_item_text( 2006, str ); }
                                                                                        >   110          void set_filename( char[] str ){ set_item_text( 2007, str ); }
                                                                                        >   111          void set_max( real m ) { max = m; }
                                                                                        >   112          void set_pos( real p ) { send_item_msg(2024,PBM_SETPOS,cast(int)(p/max*6
                                                                                        >   113  
                                                                                        >   114          bool closed()
                                                                                        >   115          {
                                                                                        >   116                  return !alive;
                                                                                        >   117          }
                                                                                        >   118  
                                                                                        >   119          void close()
                                                                                        >   120          {
                                                                                        >   121                  if( !closed )
                                                                                        >   122                          on_cancel();
                                                                                        >   123          }
                                                                                        >   124  
                                                                                        >   125  protected:
                                                                                        >   126          bool alive = false;
                                                                                        >   127          real max = 1.0;
                                                                                        >   128  
                                                                                        >   129          override void on_init()
                                                                                        >   130          {
                                                                                        >   131                  alive = true;
                                                                                        >   132                  send_item_msg( 2024, PBM_SETRANGE, 0, MAKELPARAM(0,65535) );
                                                                                        >   133  
                                                                                        >   134                  // 繧ｻ繝ｳ繧ｿ繝ｪ繝ｳ繧ｰ
                                                                                        >   135                  RECT rc,pr;
                                                                                        >   136                  GetWindowRect( handle, &rc );
                                                                                        >   137                  HWND par = GetParent(handle);
                                                                                        >   138                  if( par )
                                                                                        >   139                          GetWindowRect( par, &pr );
                                                                                        >   140                  else
                                                                                        >   141                          SystemParametersInfo( SPI_GETWORKAREA, 0, &pr, 0 );
                                                                                        >   142                  SetWindowPos( handle, null,
                                                                                        >   143                          pr.left + ( (pr.right-pr.left)-(rc.right-rc.left) )/2,
                                                                                        >   144                          pr.top  + ( (pr.bottom-pr.top)-(rc.bottom-rc.top) )/2,
                                                                                        >   145                          0, 0, SWP_NOSIZE|SWP_NOZORDER );
                                                                                        >   146  
                                                                                        >   147                  // 陦ｨ遉ｺ
                                                                                        >   148                  ShowWindow(handle,SW_SHOW);
                                                                                        >   149                  UpdateWindow(handle);
                                                                                        >   150          }
                                                                                        >   151  
                                                                                        >   152          override bool on_cancel()
                                                                                        >   153          {
                                                                                        >   154                  alive = false;
                                                                                        >   155                  DestroyWindow(handle);
                                                                                        >   156                  return true;
                                                                                        >   157          }
                                                                                        >   158  }
                                                                                        >   159  
                                                                                        >   160  //------------------------------------------------------------
                                                                                        >   161  // #2000  [繝輔ぃ繧､繝ｫ縺ｮ荳頑嶌縺咲｢ｺ隱江
                                                                                        >   162  //   2006 譖ｸ蠎ｫ蜀�繝輔ぃ繧､繝ｫ蜷�
                                                                                        >   163  //   2009 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ   564,590 Byte
                                                                                        >   164  //   2010 譖ｴ譁ｰ譌･譎�         2004\08\27 03:57:18
                                                                                        >   165  //   2007 螟夜Κ繝輔ぃ繧､繝ｫ蜷�
                                                                                        >   166  //   2011 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ
                                                                                        >   167  //   2012 譖ｴ譁ｰ譌･譎�
                                                                                        >   168  //
                                                                                        >   169  //   2002:荳頑嶌縺�  2004:譌･莉倥′譁ｰ縺励¢繧後�ｰ荳頑嶌縺� 2003:荳頑嶌縺阪＠縺ｪ縺�
                                                                                        >   170  //
                                                                                        >   171  //      1: OK繝懊ち繝ｳ
                                                                                        >   172  //   2005: 莉･髯榊�ｨ縺ｦ縺ｫ驕ｩ逕ｨ繝懊ち繝ｳ
                                                                                        >   173  //      2: 繧ｭ繝｣繝ｳ繧ｻ繝ｫ繝懊ち繝ｳ
                                                                                        >   174  //------------------------------------------------------------
                                                                                        >   175  

Added src/util.d version [97a142a9264ab72a]

                                                                                        >     1  �ｻｿprivate import std.string;
                                                                                        >     2  private import std.file;
                                                                                        >     3  private import win32.ansi.windows;
                                                                                        >     4  
                                                                                        >     5  char lastChar( char[] s )
                                                                                        >     6    { return *CharPrev(s, cast(char*)s+s.length); }
                                                                                        >     7  
                                                                                        >     8  //----------------------------------------------------------------
                                                                                        >     9  // int do_opApply!(E, C)( collection, delegate );
                                                                                        >    10  // int do_opApply!(E)   (      array, delegate );
                                                                                        >    11  //   forwarding the opApply call to another collection
                                                                                        >    12  //----------------------------------------------------------------
                                                                                        >    13  
                                                                                        >    14  template do_opApply( Elem, Collection )
                                                                                        >    15  {
                                                                                        >    16          int do_opApply( Collection c, int delegate(inout Elem) dg )
                                                                                        >    17          {
                                                                                        >    18                  int result = 0;
                                                                                        >    19                  foreach( Elem x ; c )
                                                                                        >    20                          if( 0 != (result=dg(x)) )
                                                                                        >    21                                  break;
                                                                                        >    22                  return result;
                                                                                        >    23          }
                                                                                        >    24  }
                                                                                        >    25  
                                                                                        >    26  template do_opApply( E )
                                                                                        >    27  {
                                                                                        >    28          int do_opApply( E[] c, int delegate(inout E) dg )
                                                                                        >    29          {
                                                                                        >    30                  return .do_opApply!(E,E[])( c, dg );
                                                                                        >    31          }
                                                                                        >    32  }
                                                                                        >    33  
                                                                                        >    34  //----------------------------------------------------------------
                                                                                        >    35  // class set!(T)
                                                                                        >    36  //   add    :  T -> void
                                                                                        >    37  //   remove :  T -> void
                                                                                        >    38  //   has    :  T -> bool
                                                                                        >    39  //   elems  : () -> T[]
                                                                                        >    40  //   length : () -> int
                                                                                        >    41  //----------------------------------------------------------------
                                                                                        >    42  
                                                                                        >    43  class set(T)
                                                                                        >    44  {
                                                                                        >    45          void add   ( T x ) { data[x]; }
                                                                                        >    46          void remove( T x ) { delete data[x]; }
                                                                                        >    47          bool has   ( T x ) { return x in data; }
                                                                                        >    48          T[]  elems ()      { return data.keys; }
                                                                                        >    49          int  opApply( int delegate(inout T) dg )
                                                                                        >    50                             { return do_opApply!(T)( elems, dg ); }
                                                                                        >    51          int  length()      { return data.length; }
                                                                                        >    52          private void[T] data;
                                                                                        >    53  }
                                                                                        >    54  
                                                                                        >    55  unittest
                                                                                        >    56  {
                                                                                        >    57          set!(int) x = new set!(int);
                                                                                        >    58          x.add(1);
                                                                                        >    59          x.add(2);
                                                                                        >    60          x.add(3);
                                                                                        >    61          assert( x.elems[0] + x.elems[1] + x.elems[2] == 6 );
                                                                                        >    62          assert( x.length == 3 );
                                                                                        >    63          x.remove(4);
                                                                                        >    64          x.remove(3);
                                                                                        >    65          x.remove(1);
                                                                                        >    66          assert( x.length == 1 );
                                                                                        >    67          foreach( int t ; x ) assert( t==2 );
                                                                                        >    68  }
                                                                                        >    69  
                                                                                        >    70  //----------------------------------------------------------------
                                                                                        >    71  // 繧ｳ繝槭Φ繝峨Λ繧､繝ｳ隗｣譫�
                                                                                        >    72  //----------------------------------------------------------------
                                                                                        >    73  
                                                                                        >    74  char[][] cmd_parse( char[] str, bool in_resp=false )
                                                                                        >    75  {
                                                                                        >    76          char[][] ans;
                                                                                        >    77          char resp_char = '@';
                                                                                        >    78  
                                                                                        >    79          for(int i=0; i!=str.length; )
                                                                                        >    80          {
                                                                                        >    81                  // 遨ｺ逋ｽ繧ｹ繧ｭ繝�繝�
                                                                                        >    82                  while( i!=str.length && 0<=str[i] && str[i]<=' ' )
                                                                                        >    83                          ++i;
                                                                                        >    84                  if( i == str.length )
                                                                                        >    85                          break;
                                                                                        >    86  
                                                                                        >    87                  // ""繧定��諷ｮ縺励※荳�蛟九ヱ繝ｩ繝｡繧ｿ蛻�繧雁�ｺ縺�
                                                                                        >    88                  char[] param;
                                                                                        >    89                  if( str[i] == '"' )
                                                                                        >    90                  {
                                                                                        >    91                          int j = ++i;
                                                                                        >    92                          while( j!=str.length )
                                                                                        >    93                          {
                                                                                        >    94                                  if( str[j]=='"' &&
                                                                                        >    95                                       (j+1==str.length || 0<=str[j+1] && str[j+1]
                                                                                        >    96                                          break;
                                                                                        >    97                                  ++j;
                                                                                        >    98                          }
                                                                                        >    99                          param = str[i .. j];
                                                                                        >   100                          i = (j==str.length ? j : j+1);
                                                                                        >   101                  }
                                                                                        >   102                  else
                                                                                        >   103                  {
                                                                                        >   104                          int j=i;
                                                                                        >   105                          while( j!=str.length && (str[j]<0 || ' '<str[j]) )
                                                                                        >   106                                  ++j;
                                                                                        >   107                          param = str[i .. j];
                                                                                        >   108                          i = j;
                                                                                        >   109                  }
                                                                                        >   110  
                                                                                        >   111                  // 繝ｬ繧ｹ繝昴Φ繧ｹ繝輔ぃ繧､繝ｫ髢｢騾｣縺ｮ蜃ｦ逅�
                                                                                        >   112                  if( !in_resp && param[0]==resp_char )
                                                                                        >   113                  {
                                                                                        >   114                          try {
                                                                                        >   115                                  char[] rsp = cast(char[]) std.file.read( param[1
                                                                                        >   116                                  ans ~= cmd_parse(rsp,true);
                                                                                        >   117                          } catch( FileException e ) {}
                                                                                        >   118                  }
                                                                                        >   119                  else if( param.length>=2 && param[0..2]=="--" )
                                                                                        >   120                  {
                                                                                        >   121                          resp_char = (param.length==2 ? '\0' : param[2]);
                                                                                        >   122                  }
                                                                                        >   123                  else
                                                                                        >   124                  {
                                                                                        >   125                          ans ~= param; // 譎ｮ騾壹↓繝代Λ繝｡繧ｿ霑ｽ蜉�
                                                                                        >   126                  }
                                                                                        >   127          }
                                                                                        >   128          return ans;
                                                                                        >   129  }
                                                                                        >   130  
                                                                                        >   131  //----------------------------------------------------------------
                                                                                        >   132  // DOS蠖｢蠑上〒繝輔ぃ繧､繝ｫ髻ｳ譖ｴ譁ｰ譎ょ綾繧呈嶌縺肴鋤縺�
                                                                                        >   133  //----------------------------------------------------------------
                                                                                        >   134  
                                                                                        >   135  void dosSetFTime( char[] fname, ushort date, ushort time )
                                                                                        >   136  {
                                                                                        >   137          FILETIME ft,lc;
                                                                                        >   138          if( DosDateTimeToFileTime( date, time, &lc ) )
                                                                                        >   139                  if( LocalFileTimeToFileTime( &lc, &ft ) )
                                                                                        >   140                  {
                                                                                        >   141                          HANDLE han = CreateFile( toStringz(fname),
                                                                                        >   142                                                                           GENERIC
                                                                                        >   143                                                                           FILE_SH
                                                                                        >   144                                                                           OPEN_EX
                                                                                        >   145                                                                           FILE_AT
                                                                                        >   146                                                                           NULL );
                                                                                        >   147                          if( han==INVALID_HANDLE_VALUE )
                                                                                        >   148                                  return;
                                                                                        >   149  
                                                                                        >   150                          SetFileTime( han,&ft,NULL,&ft );
                                                                                        >   151                          CloseHandle( han );
                                                                                        >   152                  }
                                                                                        >   153  }
                                                                                        >   154  
                                                                                        >   155  //----------------------------------------------------------------
                                                                                        >   156  // 謖�螳壽凾蛻ｻ(DOS蠖｢蠑�)繧医ｊ譁ｰ縺励＞繝輔ぃ繧､繝ｫ縺具ｼ�
                                                                                        >   157  //----------------------------------------------------------------
                                                                                        >   158  
                                                                                        >   159  bool newer_than( ushort d1, ushort t1, char[] fname )
                                                                                        >   160  {
                                                                                        >   161          HANDLE han = CreateFile( toStringz(fname),
                                                                                        >   162                                                           GENERIC_READ | GENERIC_
                                                                                        >   163                                                           FILE_SHARE_READ,NULL,
                                                                                        >   164                                                           OPEN_EXISTING,
                                                                                        >   165                                                           FILE_ATTRIBUTE_NORMAL,
                                                                                        >   166                                                           NULL );
                                                                                        >   167          if( han==INVALID_HANDLE_VALUE )
                                                                                        >   168                  return false;
                                                                                        >   169          FILETIME ft;
                                                                                        >   170          GetFileTime( han, null, null, &ft );
                                                                                        >   171          CloseHandle( han );
                                                                                        >   172  
                                                                                        >   173          FILETIME lc;
                                                                                        >   174          FileTimeToLocalFileTime( &ft, &lc );
                                                                                        >   175          ushort d2, t2;
                                                                                        >   176          FileTimeToDosDateTime( &lc, &d2, &t2 );
                                                                                        >   177  
                                                                                        >   178          if( d1 < d2 )
                                                                                        >   179                  return true;
                                                                                        >   180          if( d1 == d2 )
                                                                                        >   181                  return (t1 < t2);
                                                                                        >   182          return false;
                                                                                        >   183  }
                                                                                        >   184  

Added src/win32/ansi/commctrl.d version [fd91582c043f20e0]

                                                                                        >     1  module win32.ansi.commctrl;
                                                                                        >     2  
                                                                                        >     3  // Translated from Microsoft Platform SDK August 2001 Edition
                                                                                        >     4  // by Y.Tomino (demoonlit@inter7.jp)
                                                                                        >     5  
                                                                                        >     6  import win32.ansi.winuser;
                                                                                        >     7  alias void _PSP;
                                                                                        >     8  alias void _IMAGELIST;
                                                                                        >     9  alias void _TREEITEM;
                                                                                        >    10  alias LPTBSAVEPARAMW LPTBSAVEPARAMSW;
                                                                                        >    11  alias PCCOMBOEXITEMA PCCOMBOBOXEXITEMA;
                                                                                        >    12  alias PCCOMBOEXITEMW PCCOMBOBOXEXITEMW;
                                                                                        >    13  enum : uint {
                                                                                        >    14    NM_FIRST = 0,
                                                                                        >    15    SB_SETTIPTEXTA = WM_USER + 16,
                                                                                        >    16    SB_SETTIPTEXTW = WM_USER + 17,
                                                                                        >    17    SB_GETTIPTEXTA = WM_USER + 18,
                                                                                        >    18    SB_GETTIPTEXTW = WM_USER + 19,
                                                                                        >    19    TVHT_ONITEMSTATEICON = 0x0040,
                                                                                        >    20    CBEN_FIRST = 0U - 800U,
                                                                                        >    21    CBEN_GETDISPINFOA = CBEN_FIRST - 0,
                                                                                        >    22    CBEN_GETDISPINFOW = CBEN_FIRST - 7
                                                                                        >    23  }
                                                                                        >    24  // inline #include <prsht.h>
                                                                                        >    25  // ----
                                                                                        >    26  
                                                                                        >    27  // #ifndef _PRSHT_H_
                                                                                        >    28  // #define _PRSHT_H_
                                                                                        >    29  
                                                                                        >    30  // #ifndef _WINRESRC_
                                                                                        >    31  // #ifndef _WIN32_IE
                                                                                        >    32  // #...
                                                                                        >    33  // #else
                                                                                        >    34  // #if (_WIN32_IE < 0x0400) && defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
                                                                                        >    35  // #...
                                                                                        >    36  // #endif
                                                                                        >    37  // #endif
                                                                                        >    38  // #endif
                                                                                        >    39  
                                                                                        >    40  // #ifndef WINCOMMCTRLAPI
                                                                                        >    41  // #if !defined(_COMCTL32_) && defined(_WIN32)
                                                                                        >    42  // #define WINCOMMCTRLAPI DECLSPEC_IMPORT
                                                                                        >    43  // #else
                                                                                        >    44  // #...
                                                                                        >    45  // #endif
                                                                                        >    46  // #endif // WINCOMMCTRLAPI
                                                                                        >    47  
                                                                                        >    48  // #ifndef CCSIZEOF_STRUCT
                                                                                        >    49  // #define CCSIZEOF_STRUCT(structname, member) (((int)((LPBYTE)(&((structname*)0
                                                                                        >    50  // #endif
                                                                                        >    51  
                                                                                        >    52  // #ifndef DUMMYUNIONNAME
                                                                                        >    53  // #ifdef NONAMELESSUNION
                                                                                        >    54  // #...
                                                                                        >    55  // #...
                                                                                        >    56  // #...
                                                                                        >    57  // #...
                                                                                        >    58  // #...
                                                                                        >    59  // #else
                                                                                        >    60  // #define DUMMYUNIONNAME
                                                                                        >    61  // #define DUMMYUNIONNAME2
                                                                                        >    62  // #define DUMMYUNIONNAME3
                                                                                        >    63  // #define DUMMYUNIONNAME4
                                                                                        >    64  // #define DUMMYUNIONNAME5
                                                                                        >    65  // #endif
                                                                                        >    66  // #endif // DUMMYUNIONNAME
                                                                                        >    67  
                                                                                        >    68  // #ifdef _WIN64
                                                                                        >    69  // #...
                                                                                        >    70  // #else
                                                                                        >    71  align(4):
                                                                                        >    72  // #endif
                                                                                        >    73  
                                                                                        >    74  // #ifdef __cplusplus
                                                                                        >    75  // extern "C" {
                                                                                        >    76  // #endif
                                                                                        >    77  
                                                                                        >    78  // #ifndef SNDMSG
                                                                                        >    79  // #ifdef __cplusplus
                                                                                        >    80  // #ifndef _MAC
                                                                                        >    81  // #define SNDMSG ::SendMessage
                                                                                        >    82  // #else
                                                                                        >    83  // #...
                                                                                        >    84  // #endif
                                                                                        >    85  // #else
                                                                                        >    86  // #ifndef _MAC
                                                                                        >    87  // #...
                                                                                        >    88  // #else
                                                                                        >    89  // #...
                                                                                        >    90  // #endif
                                                                                        >    91  // #endif
                                                                                        >    92  // #endif // ifndef SNDMSG
                                                                                        >    93  
                                                                                        >    94  enum : uint { MAXPROPPAGES = 100 }
                                                                                        >    95  
                                                                                        >    96  // struct _PSP;
                                                                                        >    97  alias _PSP* HPROPSHEETPAGE;
                                                                                        >    98  
                                                                                        >    99  // #ifndef MIDL_PASS
                                                                                        >   100  // struct _PROPSHEETPAGEA;
                                                                                        >   101  // struct _PROPSHEETPAGEW;
                                                                                        >   102  // #endif
                                                                                        >   103  
                                                                                        >   104  extern(Windows) alias UINT function(HWND hwnd, UINT uMsg,  _PROPSHEETPAGEA *ppsp
                                                                                        >   105  extern(Windows) alias UINT function(HWND hwnd, UINT uMsg,  _PROPSHEETPAGEW *ppsp
                                                                                        >   106  
                                                                                        >   107  // #ifdef UNICODE
                                                                                        >   108  // #...
                                                                                        >   109  // #else
                                                                                        >   110  alias LPFNPSPCALLBACKA LPFNPSPCALLBACK;
                                                                                        >   111  // #endif
                                                                                        >   112  
                                                                                        >   113  enum : uint { PSP_DEFAULT = 0x00000000 }
                                                                                        >   114  enum : uint { PSP_DLGINDIRECT = 0x00000001 }
                                                                                        >   115  enum : uint { PSP_USEHICON = 0x00000002 }
                                                                                        >   116  enum : uint { PSP_USEICONID = 0x00000004 }
                                                                                        >   117  enum : uint { PSP_USETITLE = 0x00000008 }
                                                                                        >   118  enum : uint { PSP_RTLREADING = 0x00000010 }
                                                                                        >   119  
                                                                                        >   120  enum : uint { PSP_HASHELP = 0x00000020 }
                                                                                        >   121  enum : uint { PSP_USEREFPARENT = 0x00000040 }
                                                                                        >   122  enum : uint { PSP_USECALLBACK = 0x00000080 }
                                                                                        >   123  enum : uint { PSP_PREMATURE = 0x00000400 }
                                                                                        >   124  
                                                                                        >   125  // #if (_WIN32_IE >= 0x0400)
                                                                                        >   126  
                                                                                        >   127  enum : uint { PSP_HIDEHEADER = 0x00000800 }
                                                                                        >   128  enum : uint { PSP_USEHEADERTITLE = 0x00001000 }
                                                                                        >   129  enum : uint { PSP_USEHEADERSUBTITLE = 0x00002000 }
                                                                                        >   130  
                                                                                        >   131  // #endif
                                                                                        >   132  // #if (_WIN32_WINNT >= 0x0501) || ISOLATION_AWARE_ENABLED
                                                                                        >   133  enum : uint { PSP_USEFUSIONCONTEXT = 0x00004000 }
                                                                                        >   134  // #endif
                                                                                        >   135  
                                                                                        >   136  // #if (_WIN32_IE >= 0x0500)
                                                                                        >   137  enum : uint { PSPCB_ADDREF = 0 }
                                                                                        >   138  // #endif
                                                                                        >   139  enum : uint { PSPCB_RELEASE = 1 }
                                                                                        >   140  enum : uint { PSPCB_CREATE = 2 }
                                                                                        >   141  
                                                                                        >   142  // #define PROPSHEETPAGEA_V1_SIZE CCSIZEOF_STRUCT(PROPSHEETPAGEA, pcRefParent)
                                                                                        >   143  // #define PROPSHEETPAGEW_V1_SIZE CCSIZEOF_STRUCT(PROPSHEETPAGEW, pcRefParent)
                                                                                        >   144  
                                                                                        >   145  // #define PROPSHEETPAGEA_V2_SIZE CCSIZEOF_STRUCT(PROPSHEETPAGEA, pszHeaderSubTi
                                                                                        >   146  // #define PROPSHEETPAGEW_V2_SIZE CCSIZEOF_STRUCT(PROPSHEETPAGEW, pszHeaderSubTi
                                                                                        >   147  
                                                                                        >   148  // #ifdef _WIN32
                                                                                        >   149  alias LPCDLGTEMPLATE PROPSHEETPAGE_RESOURCE;
                                                                                        >   150  // #else
                                                                                        >   151  // ...
                                                                                        >   152  // #endif
                                                                                        >   153  
                                                                                        >   154  // #define PROPSHEETPAGEA_V1_FIELDS DWORD dwSize; DWORD dwFlags; HINSTANCE hInst
                                                                                        >   155  // #define PROPSHEETPAGEW_V1_FIELDS DWORD dwSize; DWORD dwFlags; HINSTANCE hInst
                                                                                        >   156  // #if (_WIN32_WINNT >= 0x0501) || ISOLATION_AWARE_ENABLED
                                                                                        >   157  alias _PROPSHEETPAGEA_V3 _PROPSHEETPAGEA;
                                                                                        >   158  alias _PROPSHEETPAGEW_V3 _PROPSHEETPAGEW;
                                                                                        >   159  // #elif (_WIN32_IE >= 0x0400)
                                                                                        >   160  // #...
                                                                                        >   161  // #...
                                                                                        >   162  // #else
                                                                                        >   163  // #...
                                                                                        >   164  // #...
                                                                                        >   165  // #endif
                                                                                        >   166  
                                                                                        >   167  struct _PROPSHEETPAGEA_V1 {
                                                                                        >   168    DWORD dwSize;
                                                                                        >   169    DWORD dwFlags;
                                                                                        >   170    HINSTANCE hInstance;
                                                                                        >   171    union {
                                                                                        >   172      LPCSTR pszTemplate;
                                                                                        >   173      PROPSHEETPAGE_RESOURCE pResource;
                                                                                        >   174    }
                                                                                        >   175    union {
                                                                                        >   176      HICON hIcon;
                                                                                        >   177      LPCSTR pszIcon;
                                                                                        >   178    }
                                                                                        >   179    LPCSTR pszTitle;
                                                                                        >   180    DLGPROC pfnDlgProc;
                                                                                        >   181    LPARAM lParam;
                                                                                        >   182    LPFNPSPCALLBACKA pfnCallback;
                                                                                        >   183    UINT* pcRefParent;
                                                                                        >   184  }
                                                                                        >   185  alias _PROPSHEETPAGEA_V1 PROPSHEETPAGEA_V1;
                                                                                        >   186  alias _PROPSHEETPAGEA_V1* LPPROPSHEETPAGEA_V1;
                                                                                        >   187  
                                                                                        >   188  alias PROPSHEETPAGEA_V1* LPCPROPSHEETPAGEA_V1;
                                                                                        >   189  
                                                                                        >   190  struct _PROPSHEETPAGEA_V2 {
                                                                                        >   191    DWORD dwSize;
                                                                                        >   192    DWORD dwFlags;
                                                                                        >   193    HINSTANCE hInstance;
                                                                                        >   194    union {
                                                                                        >   195      LPCSTR pszTemplate;
                                                                                        >   196      PROPSHEETPAGE_RESOURCE pResource;
                                                                                        >   197    }
                                                                                        >   198    union {
                                                                                        >   199      HICON hIcon;
                                                                                        >   200      LPCSTR pszIcon;
                                                                                        >   201    }
                                                                                        >   202    LPCSTR pszTitle;
                                                                                        >   203    DLGPROC pfnDlgProc;
                                                                                        >   204    LPARAM lParam;
                                                                                        >   205    LPFNPSPCALLBACKA pfnCallback;
                                                                                        >   206    UINT* pcRefParent;
                                                                                        >   207  
                                                                                        >   208    LPCSTR pszHeaderTitle;
                                                                                        >   209    LPCSTR pszHeaderSubTitle;
                                                                                        >   210  }
                                                                                        >   211  alias _PROPSHEETPAGEA_V2 PROPSHEETPAGEA_V2;
                                                                                        >   212  alias _PROPSHEETPAGEA_V2* LPPROPSHEETPAGEA_V2;
                                                                                        >   213  
                                                                                        >   214  alias PROPSHEETPAGEA_V2* LPCPROPSHEETPAGEA_V2;
                                                                                        >   215  
                                                                                        >   216  struct _PROPSHEETPAGEA_V3 {
                                                                                        >   217    DWORD dwSize;
                                                                                        >   218    DWORD dwFlags;
                                                                                        >   219    HINSTANCE hInstance;
                                                                                        >   220    union {
                                                                                        >   221      LPCSTR pszTemplate;
                                                                                        >   222      PROPSHEETPAGE_RESOURCE pResource;
                                                                                        >   223    }
                                                                                        >   224    union {
                                                                                        >   225      HICON hIcon;
                                                                                        >   226      LPCSTR pszIcon;
                                                                                        >   227    }
                                                                                        >   228    LPCSTR pszTitle;
                                                                                        >   229    DLGPROC pfnDlgProc;
                                                                                        >   230    LPARAM lParam;
                                                                                        >   231    LPFNPSPCALLBACKA pfnCallback;
                                                                                        >   232    UINT* pcRefParent;
                                                                                        >   233  
                                                                                        >   234    LPCSTR pszHeaderTitle;
                                                                                        >   235    LPCSTR pszHeaderSubTitle;
                                                                                        >   236  
                                                                                        >   237    HANDLE hActCtx;
                                                                                        >   238  }
                                                                                        >   239  alias _PROPSHEETPAGEA_V3 PROPSHEETPAGEA_V3;
                                                                                        >   240  alias _PROPSHEETPAGEA_V3* LPPROPSHEETPAGEA_V3;
                                                                                        >   241  
                                                                                        >   242  alias PROPSHEETPAGEA_V3* LPCPROPSHEETPAGEA_V3;
                                                                                        >   243  
                                                                                        >   244  struct _PROPSHEETPAGEW_V1 {
                                                                                        >   245    DWORD dwSize;
                                                                                        >   246    DWORD dwFlags;
                                                                                        >   247    HINSTANCE hInstance;
                                                                                        >   248    union {
                                                                                        >   249      LPCWSTR pszTemplate;
                                                                                        >   250      PROPSHEETPAGE_RESOURCE pResource;
                                                                                        >   251    }
                                                                                        >   252    union {
                                                                                        >   253      HICON hIcon;
                                                                                        >   254      LPCWSTR pszIcon;
                                                                                        >   255    }
                                                                                        >   256    LPCWSTR pszTitle;
                                                                                        >   257    DLGPROC pfnDlgProc;
                                                                                        >   258    LPARAM lParam;
                                                                                        >   259    LPFNPSPCALLBACKW pfnCallback;
                                                                                        >   260    UINT* pcRefParent;
                                                                                        >   261  }
                                                                                        >   262  alias _PROPSHEETPAGEW_V1 PROPSHEETPAGEW_V1;
                                                                                        >   263  alias _PROPSHEETPAGEW_V1* LPPROPSHEETPAGEW_V1;
                                                                                        >   264  
                                                                                        >   265  alias PROPSHEETPAGEW_V1* LPCPROPSHEETPAGEW_V1;
                                                                                        >   266  
                                                                                        >   267  struct _PROPSHEETPAGEW_V2 {
                                                                                        >   268    DWORD dwSize;
                                                                                        >   269    DWORD dwFlags;
                                                                                        >   270    HINSTANCE hInstance;
                                                                                        >   271    union {
                                                                                        >   272      LPCWSTR pszTemplate;
                                                                                        >   273      PROPSHEETPAGE_RESOURCE pResource;
                                                                                        >   274    }
                                                                                        >   275    union {
                                                                                        >   276      HICON hIcon;
                                                                                        >   277      LPCWSTR pszIcon;
                                                                                        >   278    }
                                                                                        >   279    LPCWSTR pszTitle;
                                                                                        >   280    DLGPROC pfnDlgProc;
                                                                                        >   281    LPARAM lParam;
                                                                                        >   282    LPFNPSPCALLBACKW pfnCallback;
                                                                                        >   283    UINT* pcRefParent;
                                                                                        >   284  
                                                                                        >   285    LPCWSTR pszHeaderTitle;
                                                                                        >   286    LPCWSTR pszHeaderSubTitle;
                                                                                        >   287  }
                                                                                        >   288  alias _PROPSHEETPAGEW_V2 PROPSHEETPAGEW_V2;
                                                                                        >   289  alias _PROPSHEETPAGEW_V2* LPPROPSHEETPAGEW_V2;
                                                                                        >   290  
                                                                                        >   291  alias PROPSHEETPAGEW_V2* LPCPROPSHEETPAGEW_V2;
                                                                                        >   292  
                                                                                        >   293  struct _PROPSHEETPAGEW_V3 {
                                                                                        >   294    DWORD dwSize;
                                                                                        >   295    DWORD dwFlags;
                                                                                        >   296    HINSTANCE hInstance;
                                                                                        >   297    union {
                                                                                        >   298      LPCWSTR pszTemplate;
                                                                                        >   299      PROPSHEETPAGE_RESOURCE pResource;
                                                                                        >   300    }
                                                                                        >   301    union {
                                                                                        >   302      HICON hIcon;
                                                                                        >   303      LPCWSTR pszIcon;
                                                                                        >   304    }
                                                                                        >   305    LPCWSTR pszTitle;
                                                                                        >   306    DLGPROC pfnDlgProc;
                                                                                        >   307    LPARAM lParam;
                                                                                        >   308    LPFNPSPCALLBACKW pfnCallback;
                                                                                        >   309    UINT* pcRefParent;
                                                                                        >   310  
                                                                                        >   311    LPCWSTR pszHeaderTitle;
                                                                                        >   312    LPCWSTR pszHeaderSubTitle;
                                                                                        >   313  
                                                                                        >   314    HANDLE hActCtx;
                                                                                        >   315  }
                                                                                        >   316  alias _PROPSHEETPAGEW_V3 PROPSHEETPAGEW_V3;
                                                                                        >   317  alias _PROPSHEETPAGEW_V3* LPPROPSHEETPAGEW_V3;
                                                                                        >   318  
                                                                                        >   319  alias PROPSHEETPAGEW_V3* LPCPROPSHEETPAGEW_V3;
                                                                                        >   320  
                                                                                        >   321  alias PROPSHEETPAGEA_V3 PROPSHEETPAGEA_LATEST;
                                                                                        >   322  alias PROPSHEETPAGEW_V3 PROPSHEETPAGEW_LATEST;
                                                                                        >   323  alias LPPROPSHEETPAGEA_V3 LPPROPSHEETPAGEA_LATEST;
                                                                                        >   324  alias LPPROPSHEETPAGEW_V3 LPPROPSHEETPAGEW_LATEST;
                                                                                        >   325  alias LPCPROPSHEETPAGEA_V3 LPCPROPSHEETPAGEA_LATEST;
                                                                                        >   326  alias LPCPROPSHEETPAGEW_V3 LPCPROPSHEETPAGEW_LATEST;
                                                                                        >   327  
                                                                                        >   328  // #if (_WIN32_WINNT >= 0x0501) || ISOLATION_AWARE_ENABLED
                                                                                        >   329  alias PROPSHEETPAGEA_V3 PROPSHEETPAGEA;
                                                                                        >   330  alias PROPSHEETPAGEW_V3 PROPSHEETPAGEW;
                                                                                        >   331  alias LPPROPSHEETPAGEA_V3 LPPROPSHEETPAGEA;
                                                                                        >   332  alias LPPROPSHEETPAGEW_V3 LPPROPSHEETPAGEW;
                                                                                        >   333  alias LPCPROPSHEETPAGEA_V3 LPCPROPSHEETPAGEA;
                                                                                        >   334  alias LPCPROPSHEETPAGEW_V3 LPCPROPSHEETPAGEW;
                                                                                        >   335  // #elif (_WIN32_IE >= 0x0400)
                                                                                        >   336  // ...
                                                                                        >   337  // #else
                                                                                        >   338  // ...
                                                                                        >   339  // #endif
                                                                                        >   340  
                                                                                        >   341  // #if 0 // IEUNIX reserved.
                                                                                        >   342  
                                                                                        >   343  // #if __STDC__ || defined (NONAMELESSUNION)
                                                                                        >   344  // #...
                                                                                        >   345  // #else
                                                                                        >   346  // #...
                                                                                        >   347  // #endif
                                                                                        >   348  // #endif
                                                                                        >   349  
                                                                                        >   350  // #ifdef UNICODE
                                                                                        >   351  // #...
                                                                                        >   352  // #...
                                                                                        >   353  // #...
                                                                                        >   354  // #...
                                                                                        >   355  // #...
                                                                                        >   356  // #...
                                                                                        >   357  // #...
                                                                                        >   358  // #...
                                                                                        >   359  // #...
                                                                                        >   360  // #...
                                                                                        >   361  // #...
                                                                                        >   362  // #...
                                                                                        >   363  // #...
                                                                                        >   364  // #...
                                                                                        >   365  // #...
                                                                                        >   366  // #...
                                                                                        >   367  // #...
                                                                                        >   368  // #else
                                                                                        >   369  alias PROPSHEETPAGEA PROPSHEETPAGE;
                                                                                        >   370  alias LPPROPSHEETPAGEA LPPROPSHEETPAGE;
                                                                                        >   371  alias LPCPROPSHEETPAGEA LPCPROPSHEETPAGE;
                                                                                        >   372  // #define PROPSHEETPAGE_V1_SIZE PROPSHEETPAGEA_V1_SIZE
                                                                                        >   373  // #define PROPSHEETPAGE_V2_SIZE PROPSHEETPAGEA_V2_SIZE
                                                                                        >   374  alias PROPSHEETPAGEA_V1 PROPSHEETPAGE_V1;
                                                                                        >   375  alias LPPROPSHEETPAGEA_V1 LPPROPSHEETPAGE_V1;
                                                                                        >   376  alias LPCPROPSHEETPAGEA_V1 LPCPROPSHEETPAGE_V1;
                                                                                        >   377  alias PROPSHEETPAGEA_V2 PROPSHEETPAGE_V2;
                                                                                        >   378  alias LPPROPSHEETPAGEA_V2 LPPROPSHEETPAGE_V2;
                                                                                        >   379  alias LPCPROPSHEETPAGEA_V2 LPCPROPSHEETPAGE_V2;
                                                                                        >   380  alias PROPSHEETPAGEA_V3 PROPSHEETPAGE_V3;
                                                                                        >   381  alias LPPROPSHEETPAGEA_V3 LPPROPSHEETPAGE_V3;
                                                                                        >   382  alias LPCPROPSHEETPAGEA_V3 LPCPROPSHEETPAGE_V3;
                                                                                        >   383  alias PROPSHEETPAGEA_LATEST PROPSHEETPAGE_LATEST;
                                                                                        >   384  alias LPPROPSHEETPAGEA_LATEST LPPROPSHEETPAGE_LATEST;
                                                                                        >   385  alias LPCPROPSHEETPAGEA_LATEST LPCPROPSHEETPAGE_LATEST;
                                                                                        >   386  // #endif
                                                                                        >   387  
                                                                                        >   388  enum : uint { PSH_DEFAULT = 0x00000000 }
                                                                                        >   389  enum : uint { PSH_PROPTITLE = 0x00000001 }
                                                                                        >   390  enum : uint { PSH_USEHICON = 0x00000002 }
                                                                                        >   391  enum : uint { PSH_USEICONID = 0x00000004 }
                                                                                        >   392  enum : uint { PSH_PROPSHEETPAGE = 0x00000008 }
                                                                                        >   393  enum : uint { PSH_WIZARDHASFINISH = 0x00000010 }
                                                                                        >   394  enum : uint { PSH_WIZARD = 0x00000020 }
                                                                                        >   395  enum : uint { PSH_USEPSTARTPAGE = 0x00000040 }
                                                                                        >   396  enum : uint { PSH_NOAPPLYNOW = 0x00000080 }
                                                                                        >   397  enum : uint { PSH_USECALLBACK = 0x00000100 }
                                                                                        >   398  enum : uint { PSH_HASHELP = 0x00000200 }
                                                                                        >   399  enum : uint { PSH_MODELESS = 0x00000400 }
                                                                                        >   400  enum : uint { PSH_RTLREADING = 0x00000800 }
                                                                                        >   401  enum : uint { PSH_WIZARDCONTEXTHELP = 0x00001000 }
                                                                                        >   402  
                                                                                        >   403  // #if (_WIN32_IE >= 0x0400)
                                                                                        >   404  
                                                                                        >   405  // #if (_WIN32_IE < 0x0500)
                                                                                        >   406  // #...
                                                                                        >   407  // #else
                                                                                        >   408  enum : uint { PSH_WIZARD97 = 0x01000000 }
                                                                                        >   409  // #endif
                                                                                        >   410  
                                                                                        >   411  enum : uint { PSH_WATERMARK = 0x00008000 }
                                                                                        >   412  enum : uint { PSH_USEHBMWATERMARK = 0x00010000 }
                                                                                        >   413  enum : uint { PSH_USEHPLWATERMARK = 0x00020000 }
                                                                                        >   414  enum : uint { PSH_STRETCHWATERMARK = 0x00040000 }
                                                                                        >   415  enum : uint { PSH_HEADER = 0x00080000 }
                                                                                        >   416  enum : uint { PSH_USEHBMHEADER = 0x00100000 }
                                                                                        >   417  enum : uint { PSH_USEPAGELANG = 0x00200000 }
                                                                                        >   418  
                                                                                        >   419  // #endif
                                                                                        >   420  
                                                                                        >   421  // #if (_WIN32_IE >= 0x0500)
                                                                                        >   422  
                                                                                        >   423  enum : uint { PSH_WIZARD_LITE = 0x00400000 }
                                                                                        >   424  enum : uint { PSH_NOCONTEXTHELP = 0x02000000 }
                                                                                        >   425  
                                                                                        >   426  // #endif
                                                                                        >   427  
                                                                                        >   428  extern(Windows) alias int function(HWND, UINT, LPARAM) PFNPROPSHEETCALLBACK;
                                                                                        >   429  
                                                                                        >   430  // #define PROPSHEETHEADERA_V1_SIZE CCSIZEOF_STRUCT(PROPSHEETHEADERA, pfnCallbac
                                                                                        >   431  // #define PROPSHEETHEADERW_V1_SIZE CCSIZEOF_STRUCT(PROPSHEETHEADERW, pfnCallbac
                                                                                        >   432  
                                                                                        >   433  // #define PROPSHEETHEADERA_V2_SIZE CCSIZEOF_STRUCT(PROPSHEETHEADERA, DUMMYUNION
                                                                                        >   434  // #define PROPSHEETHEADERW_V2_SIZE CCSIZEOF_STRUCT(PROPSHEETHEADERW, DUMMYUNION
                                                                                        >   435  
                                                                                        >   436  struct _PROPSHEETHEADERA {
                                                                                        >   437    DWORD dwSize;
                                                                                        >   438    DWORD dwFlags;
                                                                                        >   439    HWND hwndParent;
                                                                                        >   440    HINSTANCE hInstance;
                                                                                        >   441  union {
                                                                                        >   442    HICON hIcon;
                                                                                        >   443    LPCSTR pszIcon;
                                                                                        >   444  }
                                                                                        >   445  
                                                                                        >   446    LPCSTR pszCaption;
                                                                                        >   447    UINT nPages;
                                                                                        >   448  union {
                                                                                        >   449    UINT nStartPage;
                                                                                        >   450    LPCSTR pStartPage;
                                                                                        >   451  }
                                                                                        >   452  
                                                                                        >   453  union {
                                                                                        >   454    LPCPROPSHEETPAGEA ppsp;
                                                                                        >   455    HPROPSHEETPAGE *phpage;
                                                                                        >   456  }
                                                                                        >   457  
                                                                                        >   458    PFNPROPSHEETCALLBACK pfnCallback;
                                                                                        >   459  // #if (_WIN32_IE >= 0x0400)
                                                                                        >   460  union {
                                                                                        >   461    HBITMAP hbmWatermark;
                                                                                        >   462    LPCSTR pszbmWatermark;
                                                                                        >   463  }
                                                                                        >   464  
                                                                                        >   465    HPALETTE hplWatermark;
                                                                                        >   466  union {
                                                                                        >   467    HBITMAP hbmHeader;
                                                                                        >   468    LPCSTR pszbmHeader;
                                                                                        >   469  }
                                                                                        >   470  
                                                                                        >   471  // #endif
                                                                                        >   472  }
                                                                                        >   473  alias _PROPSHEETHEADERA PROPSHEETHEADERA;
                                                                                        >   474  alias _PROPSHEETHEADERA* LPPROPSHEETHEADERA;
                                                                                        >   475  
                                                                                        >   476  alias PROPSHEETHEADERA* LPCPROPSHEETHEADERA;
                                                                                        >   477  
                                                                                        >   478  struct _PROPSHEETHEADERW {
                                                                                        >   479    DWORD dwSize;
                                                                                        >   480    DWORD dwFlags;
                                                                                        >   481    HWND hwndParent;
                                                                                        >   482    HINSTANCE hInstance;
                                                                                        >   483  union {
                                                                                        >   484    HICON hIcon;
                                                                                        >   485    LPCWSTR pszIcon;
                                                                                        >   486  }
                                                                                        >   487  
                                                                                        >   488    LPCWSTR pszCaption;
                                                                                        >   489    UINT nPages;
                                                                                        >   490  union {
                                                                                        >   491    UINT nStartPage;
                                                                                        >   492    LPCWSTR pStartPage;
                                                                                        >   493  }
                                                                                        >   494  
                                                                                        >   495  union {
                                                                                        >   496    LPCPROPSHEETPAGEW ppsp;
                                                                                        >   497    HPROPSHEETPAGE *phpage;
                                                                                        >   498  }
                                                                                        >   499  
                                                                                        >   500    PFNPROPSHEETCALLBACK pfnCallback;
                                                                                        >   501  // #if (_WIN32_IE >= 0x0400)
                                                                                        >   502  union {
                                                                                        >   503    HBITMAP hbmWatermark;
                                                                                        >   504    LPCWSTR pszbmWatermark;
                                                                                        >   505  }
                                                                                        >   506  
                                                                                        >   507    HPALETTE hplWatermark;
                                                                                        >   508  union {
                                                                                        >   509    HBITMAP hbmHeader;
                                                                                        >   510    LPCWSTR pszbmHeader;
                                                                                        >   511  }
                                                                                        >   512  
                                                                                        >   513  // #endif
                                                                                        >   514  }
                                                                                        >   515  alias _PROPSHEETHEADERW PROPSHEETHEADERW;
                                                                                        >   516  alias _PROPSHEETHEADERW* LPPROPSHEETHEADERW;
                                                                                        >   517  
                                                                                        >   518  alias PROPSHEETHEADERW* LPCPROPSHEETHEADERW;
                                                                                        >   519  
                                                                                        >   520  // #if 0 //IEUNIX reserved.
                                                                                        >   521  
                                                                                        >   522  // #if __STDC__ || defined (NONAMELESSUNION)
                                                                                        >   523  // #...
                                                                                        >   524  // #...
                                                                                        >   525  // #else
                                                                                        >   526  // #...
                                                                                        >   527  // #...
                                                                                        >   528  // #endif
                                                                                        >   529  // #endif
                                                                                        >   530  
                                                                                        >   531  // #ifdef UNICODE
                                                                                        >   532  // #...
                                                                                        >   533  // #...
                                                                                        >   534  // #...
                                                                                        >   535  // #...
                                                                                        >   536  // #...
                                                                                        >   537  // #else
                                                                                        >   538  alias PROPSHEETHEADERA PROPSHEETHEADER;
                                                                                        >   539  alias LPPROPSHEETHEADERA LPPROPSHEETHEADER;
                                                                                        >   540  alias LPCPROPSHEETHEADERA LPCPROPSHEETHEADER;
                                                                                        >   541  // #define PROPSHEETHEADER_V1_SIZE PROPSHEETHEADERA_V1_SIZE
                                                                                        >   542  // #define PROPSHEETHEADER_V2_SIZE PROPSHEETHEADERA_V2_SIZE
                                                                                        >   543  // #endif
                                                                                        >   544  
                                                                                        >   545  enum : uint { PSCB_INITIALIZED = 1 }
                                                                                        >   546  enum : uint { PSCB_PRECREATE = 2 }
                                                                                        >   547  
                                                                                        >   548  // #if (_WIN32_IE >= 0x560)
                                                                                        >   549  
                                                                                        >   550  enum : uint { PSCB_BUTTONPRESSED = 3 }
                                                                                        >   551  // #endif  // _WIN32_IE >= 0x560
                                                                                        >   552  
                                                                                        >   553  extern(Windows) export HPROPSHEETPAGE CreatePropertySheetPageA(LPCPROPSHEETPAGEA
                                                                                        >   554  extern(Windows) export HPROPSHEETPAGE CreatePropertySheetPageW(LPCPROPSHEETPAGEW
                                                                                        >   555  extern(Windows) export BOOL DestroyPropertySheetPage(HPROPSHEETPAGE);
                                                                                        >   556  
                                                                                        >   557  extern(Windows) export INT_PTR PropertySheetA(LPCPROPSHEETHEADERA);
                                                                                        >   558  
                                                                                        >   559  extern(Windows) export INT_PTR PropertySheetW(LPCPROPSHEETHEADERW);
                                                                                        >   560  
                                                                                        >   561  // #ifdef UNICODE
                                                                                        >   562  // #...
                                                                                        >   563  // #...
                                                                                        >   564  // #else
                                                                                        >   565  alias CreatePropertySheetPageA CreatePropertySheetPage;
                                                                                        >   566  alias PropertySheetA PropertySheet;
                                                                                        >   567  // #endif
                                                                                        >   568  
                                                                                        >   569  extern(Windows) alias BOOL function(HPROPSHEETPAGE, LPARAM) LPFNADDPROPSHEETPAGE
                                                                                        >   570  extern(Windows) alias BOOL function(LPVOID, LPFNADDPROPSHEETPAGE, LPARAM) LPFNAD
                                                                                        >   571  
                                                                                        >   572  struct _PSHNOTIFY {
                                                                                        >   573    NMHDR hdr;
                                                                                        >   574    LPARAM lParam;
                                                                                        >   575  }
                                                                                        >   576  alias _PSHNOTIFY PSHNOTIFY;
                                                                                        >   577  alias _PSHNOTIFY* LPPSHNOTIFY;
                                                                                        >   578  
                                                                                        >   579  enum : uint { PSN_FIRST = 0U-200U }
                                                                                        >   580  enum : uint { PSN_LAST = 0U-299U }
                                                                                        >   581  
                                                                                        >   582  enum : uint { PSN_SETACTIVE = PSN_FIRST-0 }
                                                                                        >   583  enum : uint { PSN_KILLACTIVE = PSN_FIRST-1 }
                                                                                        >   584  
                                                                                        >   585  enum : uint { PSN_APPLY = PSN_FIRST-2 }
                                                                                        >   586  enum : uint { PSN_RESET = PSN_FIRST-3 }
                                                                                        >   587  
                                                                                        >   588  enum : uint { PSN_HELP = PSN_FIRST-5 }
                                                                                        >   589  enum : uint { PSN_WIZBACK = PSN_FIRST-6 }
                                                                                        >   590  enum : uint { PSN_WIZNEXT = PSN_FIRST-7 }
                                                                                        >   591  enum : uint { PSN_WIZFINISH = PSN_FIRST-8 }
                                                                                        >   592  enum : uint { PSN_QUERYCANCEL = PSN_FIRST-9 }
                                                                                        >   593  // #if (_WIN32_IE >= 0x0400)
                                                                                        >   594  enum : uint { PSN_GETOBJECT = PSN_FIRST-10 }
                                                                                        >   595  // #endif // 0x0400
                                                                                        >   596  // #if (_WIN32_IE >= 0x0500)
                                                                                        >   597  enum : uint { PSN_TRANSLATEACCELERATOR = PSN_FIRST-12 }
                                                                                        >   598  enum : uint { PSN_QUERYINITIALFOCUS = PSN_FIRST-13 }
                                                                                        >   599  // #endif // 0x0500
                                                                                        >   600  
                                                                                        >   601  enum : uint { PSNRET_NOERROR = 0 }
                                                                                        >   602  enum : uint { PSNRET_INVALID = 1 }
                                                                                        >   603  enum : uint { PSNRET_INVALID_NOCHANGEPAGE = 2 }
                                                                                        >   604  enum : uint { PSNRET_MESSAGEHANDLED = 3 }
                                                                                        >   605  
                                                                                        >   606  enum : uint { PSM_SETCURSEL = WM_USER + 101 }
                                                                                        >   607  // #define PropSheet_SetCurSel(hDlg, hpage, index) SNDMSG(hDlg, PSM_SETCURSEL, (
                                                                                        >   608  
                                                                                        >   609  enum : uint { PSM_REMOVEPAGE = WM_USER + 102 }
                                                                                        >   610  // #define PropSheet_RemovePage(hDlg, index, hpage) SNDMSG(hDlg, PSM_REMOVEPAGE,
                                                                                        >   611  
                                                                                        >   612  enum : uint { PSM_ADDPAGE = WM_USER + 103 }
                                                                                        >   613  // #define PropSheet_AddPage(hDlg, hpage) SNDMSG(hDlg, PSM_ADDPAGE, 0, (LPARAM)h
                                                                                        >   614  
                                                                                        >   615  enum : uint { PSM_CHANGED = WM_USER + 104 }
                                                                                        >   616  // #define PropSheet_Changed(hDlg, hwnd) SNDMSG(hDlg, PSM_CHANGED, (WPARAM)hwnd,
                                                                                        >   617  
                                                                                        >   618  enum : uint { PSM_RESTARTWINDOWS = WM_USER + 105 }
                                                                                        >   619  // #define PropSheet_RestartWindows(hDlg) SNDMSG(hDlg, PSM_RESTARTWINDOWS, 0, 0L
                                                                                        >   620  
                                                                                        >   621  enum : uint { PSM_REBOOTSYSTEM = WM_USER + 106 }
                                                                                        >   622  // #define PropSheet_RebootSystem(hDlg) SNDMSG(hDlg, PSM_REBOOTSYSTEM, 0, 0L)
                                                                                        >   623  
                                                                                        >   624  enum : uint { PSM_CANCELTOCLOSE = WM_USER + 107 }
                                                                                        >   625  // #define PropSheet_CancelToClose(hDlg) PostMessage(hDlg, PSM_CANCELTOCLOSE, 0,
                                                                                        >   626  
                                                                                        >   627  enum : uint { PSM_QUERYSIBLINGS = WM_USER + 108 }
                                                                                        >   628  // #define PropSheet_QuerySiblings(hDlg, wParam, lParam) SNDMSG(hDlg, PSM_QUERYS
                                                                                        >   629  
                                                                                        >   630  enum : uint { PSM_UNCHANGED = WM_USER + 109 }
                                                                                        >   631  // #define PropSheet_UnChanged(hDlg, hwnd) SNDMSG(hDlg, PSM_UNCHANGED, (WPARAM)h
                                                                                        >   632  
                                                                                        >   633  enum : uint { PSM_APPLY = WM_USER + 110 }
                                                                                        >   634  // #define PropSheet_Apply(hDlg) SNDMSG(hDlg, PSM_APPLY, 0, 0L)
                                                                                        >   635  
                                                                                        >   636  enum : uint { PSM_SETTITLEA = WM_USER + 111 }
                                                                                        >   637  enum : uint { PSM_SETTITLEW = WM_USER + 120 }
                                                                                        >   638  
                                                                                        >   639  // #ifdef UNICODE
                                                                                        >   640  // #...
                                                                                        >   641  // #else
                                                                                        >   642  alias PSM_SETTITLEA PSM_SETTITLE;
                                                                                        >   643  // #endif
                                                                                        >   644  
                                                                                        >   645  // #define PropSheet_SetTitle(hDlg, wStyle, lpszText) SNDMSG(hDlg, PSM_SETTITLE,
                                                                                        >   646  
                                                                                        >   647  enum : uint { PSM_SETWIZBUTTONS = WM_USER + 112 }
                                                                                        >   648  // #define PropSheet_SetWizButtons(hDlg, dwFlags) PostMessage(hDlg, PSM_SETWIZBU
                                                                                        >   649  
                                                                                        >   650  enum : uint { PSWIZB_BACK = 0x00000001 }
                                                                                        >   651  enum : uint { PSWIZB_NEXT = 0x00000002 }
                                                                                        >   652  enum : uint { PSWIZB_FINISH = 0x00000004 }
                                                                                        >   653  enum : uint { PSWIZB_DISABLEDFINISH = 0x00000008 }
                                                                                        >   654  
                                                                                        >   655  enum : uint { PSM_PRESSBUTTON = WM_USER + 113 }
                                                                                        >   656  // #define PropSheet_PressButton(hDlg, iButton) PostMessage(hDlg, PSM_PRESSBUTTO
                                                                                        >   657  
                                                                                        >   658  enum : uint { PSBTN_BACK = 0 }
                                                                                        >   659  enum : uint { PSBTN_NEXT = 1 }
                                                                                        >   660  enum : uint { PSBTN_FINISH = 2 }
                                                                                        >   661  enum : uint { PSBTN_OK = 3 }
                                                                                        >   662  enum : uint { PSBTN_APPLYNOW = 4 }
                                                                                        >   663  enum : uint { PSBTN_CANCEL = 5 }
                                                                                        >   664  enum : uint { PSBTN_HELP = 6 }
                                                                                        >   665  enum : uint { PSBTN_MAX = 6 }
                                                                                        >   666  
                                                                                        >   667  enum : uint { PSM_SETCURSELID = WM_USER + 114 }
                                                                                        >   668  // #define PropSheet_SetCurSelByID(hDlg, id) SNDMSG(hDlg, PSM_SETCURSELID, 0, (L
                                                                                        >   669  
                                                                                        >   670  enum : uint { PSM_SETFINISHTEXTA = WM_USER + 115 }
                                                                                        >   671  enum : uint { PSM_SETFINISHTEXTW = WM_USER + 121 }
                                                                                        >   672  
                                                                                        >   673  // #ifdef UNICODE
                                                                                        >   674  // #...
                                                                                        >   675  // #else
                                                                                        >   676  alias PSM_SETFINISHTEXTA PSM_SETFINISHTEXT;
                                                                                        >   677  // #endif
                                                                                        >   678  
                                                                                        >   679  // #define PropSheet_SetFinishText(hDlg, lpszText) SNDMSG(hDlg, PSM_SETFINISHTEX
                                                                                        >   680  
                                                                                        >   681  enum : uint { PSM_GETTABCONTROL = WM_USER + 116 }
                                                                                        >   682  // #define PropSheet_GetTabControl(hDlg) (HWND)SNDMSG(hDlg, PSM_GETTABCONTROL, 0
                                                                                        >   683  
                                                                                        >   684  enum : uint { PSM_ISDIALOGMESSAGE = WM_USER + 117 }
                                                                                        >   685  // #define PropSheet_IsDialogMessage(hDlg, pMsg) (BOOL)SNDMSG(hDlg, PSM_ISDIALOG
                                                                                        >   686  
                                                                                        >   687  enum : uint { PSM_GETCURRENTPAGEHWND = WM_USER + 118 }
                                                                                        >   688  // #define PropSheet_GetCurrentPageHwnd(hDlg) (HWND)SNDMSG(hDlg, PSM_GETCURRENTP
                                                                                        >   689  
                                                                                        >   690  enum : uint { PSM_INSERTPAGE = WM_USER + 119 }
                                                                                        >   691  // #define PropSheet_InsertPage(hDlg, index, hpage) SNDMSG(hDlg, PSM_INSERTPAGE,
                                                                                        >   692  
                                                                                        >   693  // #if (_WIN32_IE >= 0x0500)
                                                                                        >   694  enum : uint { PSM_SETHEADERTITLEA = WM_USER + 125 }
                                                                                        >   695  enum : uint { PSM_SETHEADERTITLEW = WM_USER + 126 }
                                                                                        >   696  
                                                                                        >   697  // #ifdef UNICODE
                                                                                        >   698  // #...
                                                                                        >   699  // #else
                                                                                        >   700  alias PSM_SETHEADERTITLEA PSM_SETHEADERTITLE;
                                                                                        >   701  // #endif
                                                                                        >   702  
                                                                                        >   703  // #define PropSheet_SetHeaderTitle(hDlg, index, lpszText) SNDMSG(hDlg, PSM_SETH
                                                                                        >   704  
                                                                                        >   705  enum : uint { PSM_SETHEADERSUBTITLEA = WM_USER + 127 }
                                                                                        >   706  enum : uint { PSM_SETHEADERSUBTITLEW = WM_USER + 128 }
                                                                                        >   707  
                                                                                        >   708  // #ifdef UNICODE
                                                                                        >   709  // #...
                                                                                        >   710  // #else
                                                                                        >   711  alias PSM_SETHEADERSUBTITLEA PSM_SETHEADERSUBTITLE;
                                                                                        >   712  // #endif
                                                                                        >   713  
                                                                                        >   714  // #define PropSheet_SetHeaderSubTitle(hDlg, index, lpszText) SNDMSG(hDlg, PSM_S
                                                                                        >   715  
                                                                                        >   716  enum : uint { PSM_HWNDTOINDEX = WM_USER + 129 }
                                                                                        >   717  // #define PropSheet_HwndToIndex(hDlg, hwnd) (int)SNDMSG(hDlg, PSM_HWNDTOINDEX, 
                                                                                        >   718  
                                                                                        >   719  enum : uint { PSM_INDEXTOHWND = WM_USER + 130 }
                                                                                        >   720  // #define PropSheet_IndexToHwnd(hDlg, i) (HWND)SNDMSG(hDlg, PSM_INDEXTOHWND, (W
                                                                                        >   721  
                                                                                        >   722  enum : uint { PSM_PAGETOINDEX = WM_USER + 131 }
                                                                                        >   723  // #define PropSheet_PageToIndex(hDlg, hpage) (int)SNDMSG(hDlg, PSM_PAGETOINDEX,
                                                                                        >   724  
                                                                                        >   725  enum : uint { PSM_INDEXTOPAGE = WM_USER + 132 }
                                                                                        >   726  // #define PropSheet_IndexToPage(hDlg, i) (HPROPSHEETPAGE)SNDMSG(hDlg, PSM_INDEX
                                                                                        >   727  
                                                                                        >   728  enum : uint { PSM_IDTOINDEX = WM_USER + 133 }
                                                                                        >   729  // #define PropSheet_IdToIndex(hDlg, id) (int)SNDMSG(hDlg, PSM_IDTOINDEX, 0, (LP
                                                                                        >   730  
                                                                                        >   731  enum : uint { PSM_INDEXTOID = WM_USER + 134 }
                                                                                        >   732  // #define PropSheet_IndexToId(hDlg, i) SNDMSG(hDlg, PSM_INDEXTOID, (WPARAM)(i),
                                                                                        >   733  
                                                                                        >   734  enum : uint { PSM_GETRESULT = WM_USER + 135 }
                                                                                        >   735  // #define PropSheet_GetResult(hDlg) SNDMSG(hDlg, PSM_GETRESULT, 0, 0)
                                                                                        >   736  
                                                                                        >   737  enum : uint { PSM_RECALCPAGESIZES = WM_USER + 136 }
                                                                                        >   738  // #define PropSheet_RecalcPageSizes(hDlg) SNDMSG(hDlg, PSM_RECALCPAGESIZES, 0, 
                                                                                        >   739  // #endif // 0x0500
                                                                                        >   740  
                                                                                        >   741  enum : uint { ID_PSRESTARTWINDOWS = 0x2 }
                                                                                        >   742  enum : uint { ID_PSREBOOTSYSTEM = ID_PSRESTARTWINDOWS | 0x1 }
                                                                                        >   743  
                                                                                        >   744  enum : uint { WIZ_CXDLG = 276 }
                                                                                        >   745  enum : uint { WIZ_CYDLG = 140 }
                                                                                        >   746  
                                                                                        >   747  enum : uint { WIZ_CXBMP = 80 }
                                                                                        >   748  
                                                                                        >   749  enum : uint { WIZ_BODYX = 92 }
                                                                                        >   750  enum : uint { WIZ_BODYCX = 184 }
                                                                                        >   751  
                                                                                        >   752  enum : uint { PROP_SM_CXDLG = 212 }
                                                                                        >   753  enum : uint { PROP_SM_CYDLG = 188 }
                                                                                        >   754  
                                                                                        >   755  enum : uint { PROP_MED_CXDLG = 227 }
                                                                                        >   756  enum : uint { PROP_MED_CYDLG = 215 }
                                                                                        >   757  
                                                                                        >   758  enum : uint { PROP_LG_CXDLG = 252 }
                                                                                        >   759  enum : uint { PROP_LG_CYDLG = 218 }
                                                                                        >   760  
                                                                                        >   761  // #if !defined(RC_INVOKED) /* RC complains about long symbols in #ifs */
                                                                                        >   762  // #if ISOLATION_AWARE_ENABLED
                                                                                        >   763  
                                                                                        >   764  // #if !defined(ISOLATION_AWARE_INLINE)
                                                                                        >   765  // #if defined(__cplusplus)
                                                                                        >   766  // #...
                                                                                        >   767  // #else
                                                                                        >   768  // #...
                                                                                        >   769  // #endif
                                                                                        >   770  // #endif
                                                                                        >   771  
                                                                                        >   772  // ...
                                                                                        >   773  
                                                                                        >   774  // #ifndef CCSIZEOF_STRUCT
                                                                                        >   775  // #...
                                                                                        >   776  // #endif
                                                                                        >   777  
                                                                                        >   778  // ...
                                                                                        >   779  
                                                                                        >   780  // #if defined(UNICODE)
                                                                                        >   781  
                                                                                        >   782  // #...
                                                                                        >   783  // #...
                                                                                        >   784  
                                                                                        >   785  // #else /* UNICODE */
                                                                                        >   786  
                                                                                        >   787  // #...
                                                                                        >   788  // #...
                                                                                        >   789  
                                                                                        >   790  // #endif /* UNICODE */
                                                                                        >   791  
                                                                                        >   792  // ...
                                                                                        >   793  
                                                                                        >   794  // ...
                                                                                        >   795  
                                                                                        >   796  // ...
                                                                                        >   797  
                                                                                        >   798  // ...
                                                                                        >   799  
                                                                                        >   800  // ...
                                                                                        >   801  
                                                                                        >   802  // ...
                                                                                        >   803  
                                                                                        >   804  // ...
                                                                                        >   805  
                                                                                        >   806  // ...
                                                                                        >   807  
                                                                                        >   808  // ...
                                                                                        >   809  
                                                                                        >   810  // ...
                                                                                        >   811  
                                                                                        >   812  // #...
                                                                                        >   813  // #...
                                                                                        >   814  // #...
                                                                                        >   815  // #...
                                                                                        >   816  // #...
                                                                                        >   817  
                                                                                        >   818  // #endif /* ISOLATION_AWARE_ENABLED */
                                                                                        >   819  // #endif /* RC */
                                                                                        >   820  
                                                                                        >   821  // #ifdef __cplusplus
                                                                                        >   822  // }
                                                                                        >   823  // #endif
                                                                                        >   824  
                                                                                        >   825  align:
                                                                                        >   826  
                                                                                        >   827  // #endif  // _PRSHT_H_
                                                                                        >   828  
                                                                                        >   829  // ----
                                                                                        >   830  
                                                                                        >   831  // #ifndef _INC_COMMCTRL
                                                                                        >   832  // #define _INC_COMMCTRL
                                                                                        >   833  
                                                                                        >   834  // #ifndef _WINRESRC_
                                                                                        >   835  // #ifndef _WIN32_IE
                                                                                        >   836  // #...
                                                                                        >   837  // #else
                                                                                        >   838  // #if (_WIN32_IE < 0x0400) && defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
                                                                                        >   839  // #...
                                                                                        >   840  // #endif
                                                                                        >   841  // #endif
                                                                                        >   842  // #endif
                                                                                        >   843  
                                                                                        >   844  // #ifndef _HRESULT_DEFINED
                                                                                        >   845  // #define _HRESULT_DEFINED
                                                                                        >   846  alias LONG HRESULT;
                                                                                        >   847  // #endif // _HRESULT_DEFINED
                                                                                        >   848  
                                                                                        >   849  // #ifndef NOUSER
                                                                                        >   850  
                                                                                        >   851  // #ifndef WINCOMMCTRLAPI
                                                                                        >   852  // #if !defined(_COMCTL32_) && defined(_WIN32)
                                                                                        >   853  // #define WINCOMMCTRLAPI DECLSPEC_IMPORT
                                                                                        >   854  // #else
                                                                                        >   855  // #...
                                                                                        >   856  // #endif
                                                                                        >   857  // #endif // WINCOMMCTRLAPI
                                                                                        >   858  
                                                                                        >   859  // #ifndef DUMMYUNIONNAME
                                                                                        >   860  // #ifdef NONAMELESSUNION
                                                                                        >   861  // #...
                                                                                        >   862  // #...
                                                                                        >   863  // #...
                                                                                        >   864  // #...
                                                                                        >   865  // #...
                                                                                        >   866  // #else
                                                                                        >   867  // #define DUMMYUNIONNAME
                                                                                        >   868  // #define DUMMYUNIONNAME2
                                                                                        >   869  // #define DUMMYUNIONNAME3
                                                                                        >   870  // #define DUMMYUNIONNAME4
                                                                                        >   871  // #define DUMMYUNIONNAME5
                                                                                        >   872  // #endif
                                                                                        >   873  // #endif // DUMMYUNIONNAME
                                                                                        >   874  
                                                                                        >   875  // #ifdef __cplusplus
                                                                                        >   876  // extern "C" {
                                                                                        >   877  // #endif
                                                                                        >   878  
                                                                                        >   879  // #include <prsht.h>
                                                                                        >   880  
                                                                                        >   881  // #ifndef SNDMSG
                                                                                        >   882  // #ifdef __cplusplus
                                                                                        >   883  // #ifndef _MAC
                                                                                        >   884  // #define SNDMSG ::SendMessage
                                                                                        >   885  // #else
                                                                                        >   886  // #...
                                                                                        >   887  // #endif
                                                                                        >   888  // #else
                                                                                        >   889  // #ifndef _MAC
                                                                                        >   890  // #...
                                                                                        >   891  // #else
                                                                                        >   892  // #...
                                                                                        >   893  // #endif //_MAC
                                                                                        >   894  // #endif
                                                                                        >   895  // #endif // ifndef SNDMSG
                                                                                        >   896  
                                                                                        >   897  // #ifdef _MAC
                                                                                        >   898  // #ifndef RC_INVOKED
                                                                                        >   899  // #ifndef _WLM_NOFORCE_LIBS
                                                                                        >   900  
                                                                                        >   901  // #ifndef _WLMDLL
                                                                                        >   902  //     #ifdef _DEBUG
                                                                                        >   903  // #...
                                                                                        >   904  //     #else
                                                                                        >   905  // #...
                                                                                        >   906  //     #endif
                                                                                        >   907  // #...
                                                                                        >   908  //     #else
                                                                                        >   909  //     #ifdef _DEBUG
                                                                                        >   910  // #...
                                                                                        >   911  //     #else
                                                                                        >   912  // #...
                                                                                        >   913  //     #endif
                                                                                        >   914  // #endif // _WLMDLL
                                                                                        >   915  
                                                                                        >   916  // #endif // _WLM_NOFORCE_LIBS
                                                                                        >   917  // #endif // RC_INVOKED
                                                                                        >   918  // #endif //_MAC
                                                                                        >   919  
                                                                                        >   920  extern(Windows) export void InitCommonControls();
                                                                                        >   921  
                                                                                        >   922  // #if (_WIN32_IE >= 0x0300)
                                                                                        >   923  struct tagINITCOMMONCONTROLSEX {
                                                                                        >   924    DWORD dwSize;
                                                                                        >   925    DWORD dwICC;
                                                                                        >   926  }
                                                                                        >   927  alias tagINITCOMMONCONTROLSEX INITCOMMONCONTROLSEX;
                                                                                        >   928  alias tagINITCOMMONCONTROLSEX* LPINITCOMMONCONTROLSEX;
                                                                                        >   929  
                                                                                        >   930  enum : uint { ICC_LISTVIEW_CLASSES = 0x00000001 }
                                                                                        >   931  enum : uint { ICC_TREEVIEW_CLASSES = 0x00000002 }
                                                                                        >   932  enum : uint { ICC_BAR_CLASSES = 0x00000004 }
                                                                                        >   933  enum : uint { ICC_TAB_CLASSES = 0x00000008 }
                                                                                        >   934  enum : uint { ICC_UPDOWN_CLASS = 0x00000010 }
                                                                                        >   935  enum : uint { ICC_PROGRESS_CLASS = 0x00000020 }
                                                                                        >   936  enum : uint { ICC_HOTKEY_CLASS = 0x00000040 }
                                                                                        >   937  enum : uint { ICC_ANIMATE_CLASS = 0x00000080 }
                                                                                        >   938  enum : uint { ICC_WIN95_CLASSES = 0x000000FF }
                                                                                        >   939  enum : uint { ICC_DATE_CLASSES = 0x00000100 }
                                                                                        >   940  enum : uint { ICC_USEREX_CLASSES = 0x00000200 }
                                                                                        >   941  enum : uint { ICC_COOL_CLASSES = 0x00000400 }
                                                                                        >   942  // #if (_WIN32_IE >= 0x0400)
                                                                                        >   943  enum : uint { ICC_INTERNET_CLASSES = 0x00000800 }
                                                                                        >   944  enum : uint { ICC_PAGESCROLLER_CLASS = 0x00001000 }
                                                                                        >   945  enum : uint { ICC_NATIVEFNTCTL_CLASS = 0x00002000 }
                                                                                        >   946  // #endif
                                                                                        >   947  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >   948  enum : uint { ICC_STANDARD_CLASSES = 0x00004000 }
                                                                                        >   949  enum : uint { ICC_LINK_CLASS = 0x00008000 }
                                                                                        >   950  // #endif
                                                                                        >   951  
                                                                                        >   952  extern(Windows) export BOOL InitCommonControlsEx(LPINITCOMMONCONTROLSEX);
                                                                                        >   953  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >   954  
                                                                                        >   955  enum : uint { ODT_HEADER = 100 }
                                                                                        >   956  enum : uint { ODT_TAB = 101 }
                                                                                        >   957  enum : uint { ODT_LISTVIEW = 102 }
                                                                                        >   958  
                                                                                        >   959  enum : uint { LVM_FIRST = 0x1000 }
                                                                                        >   960  enum : uint { TV_FIRST = 0x1100 }
                                                                                        >   961  enum : uint { HDM_FIRST = 0x1200 }
                                                                                        >   962  enum : uint { TCM_FIRST = 0x1300 }
                                                                                        >   963  
                                                                                        >   964  // #if (_WIN32_IE >= 0x0400)
                                                                                        >   965  enum : uint { PGM_FIRST = 0x1400 }
                                                                                        >   966  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >   967  enum : uint { ECM_FIRST = 0x1500 }
                                                                                        >   968  enum : uint { BCM_FIRST = 0x1600 }
                                                                                        >   969  enum : uint { CBM_FIRST = 0x1700 }
                                                                                        >   970  // #endif
                                                                                        >   971  enum : uint { CCM_FIRST = 0x2000 }
                                                                                        >   972  enum : uint { CCM_LAST = CCM_FIRST + 0x200 }
                                                                                        >   973  
                                                                                        >   974  enum : uint { CCM_SETBKCOLOR = CCM_FIRST + 1 }
                                                                                        >   975  
                                                                                        >   976  struct tagCOLORSCHEME {
                                                                                        >   977    DWORD dwSize;
                                                                                        >   978    COLORREF clrBtnHighlight;
                                                                                        >   979    COLORREF clrBtnShadow;
                                                                                        >   980  }
                                                                                        >   981  alias tagCOLORSCHEME COLORSCHEME;
                                                                                        >   982  alias tagCOLORSCHEME* LPCOLORSCHEME;
                                                                                        >   983  
                                                                                        >   984  enum : uint { CCM_SETCOLORSCHEME = CCM_FIRST + 2 }
                                                                                        >   985  enum : uint { CCM_GETCOLORSCHEME = CCM_FIRST + 3 }
                                                                                        >   986  enum : uint { CCM_GETDROPTARGET = CCM_FIRST + 4 }
                                                                                        >   987  enum : uint { CCM_SETUNICODEFORMAT = CCM_FIRST + 5 }
                                                                                        >   988  enum : uint { CCM_GETUNICODEFORMAT = CCM_FIRST + 6 }
                                                                                        >   989  
                                                                                        >   990  // #if (_WIN32_IE >= 0x0500)
                                                                                        >   991  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >   992  enum : uint { COMCTL32_VERSION = 6 }
                                                                                        >   993  // #else
                                                                                        >   994  // #...
                                                                                        >   995  // #endif
                                                                                        >   996  
                                                                                        >   997  enum : uint { CCM_SETVERSION = CCM_FIRST + 0x7 }
                                                                                        >   998  enum : uint { CCM_GETVERSION = CCM_FIRST + 0x8 }
                                                                                        >   999  enum : uint { CCM_SETNOTIFYWINDOW = CCM_FIRST + 0x9 }
                                                                                        >  1000  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1001  enum : uint { CCM_SETWINDOWTHEME = CCM_FIRST + 0xb }
                                                                                        >  1002  enum : uint { CCM_DPISCALE = CCM_FIRST + 0xc }
                                                                                        >  1003  // #endif
                                                                                        >  1004  // #endif // (_WIN32_IE >= 0x0500)
                                                                                        >  1005  
                                                                                        >  1006  // #endif // (_WIN32_IE >= 0x0400)
                                                                                        >  1007  
                                                                                        >  1008  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1009  
                                                                                        >  1010  enum : uint { INFOTIPSIZE = 1024 }
                                                                                        >  1011  // #endif
                                                                                        >  1012  
                                                                                        >  1013  // #define HANDLE_WM_NOTIFY(hwnd, wParam, lParam, fn) (fn)((hwnd), (int)(wParam)
                                                                                        >  1014  // #define FORWARD_WM_NOTIFY(hwnd, idFrom, pnmhdr, fn) (LRESULT)(fn)((hwnd), WM_
                                                                                        >  1015  
                                                                                        >  1016  enum : uint { NM_OUTOFMEMORY = NM_FIRST-1 }
                                                                                        >  1017  enum : uint { NM_CLICK = NM_FIRST-2 }
                                                                                        >  1018  enum : uint { NM_DBLCLK = NM_FIRST-3 }
                                                                                        >  1019  enum : uint { NM_RETURN = NM_FIRST-4 }
                                                                                        >  1020  enum : uint { NM_RCLICK = NM_FIRST-5 }
                                                                                        >  1021  enum : uint { NM_RDBLCLK = NM_FIRST-6 }
                                                                                        >  1022  enum : uint { NM_SETFOCUS = NM_FIRST-7 }
                                                                                        >  1023  enum : uint { NM_KILLFOCUS = NM_FIRST-8 }
                                                                                        >  1024  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1025  enum : uint { NM_CUSTOMDRAW = NM_FIRST-12 }
                                                                                        >  1026  enum : uint { NM_HOVER = NM_FIRST-13 }
                                                                                        >  1027  // #endif
                                                                                        >  1028  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1029  enum : uint { NM_NCHITTEST = NM_FIRST-14 }
                                                                                        >  1030  enum : uint { NM_KEYDOWN = NM_FIRST-15 }
                                                                                        >  1031  enum : uint { NM_RELEASEDCAPTURE = NM_FIRST-16 }
                                                                                        >  1032  enum : uint { NM_SETCURSOR = NM_FIRST-17 }
                                                                                        >  1033  enum : uint { NM_CHAR = NM_FIRST-18 }
                                                                                        >  1034  // #endif
                                                                                        >  1035  // #if (_WIN32_IE >= 0x0401)
                                                                                        >  1036  enum : uint { NM_TOOLTIPSCREATED = NM_FIRST-19 }
                                                                                        >  1037  // #endif
                                                                                        >  1038  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1039  enum : uint { NM_LDOWN = NM_FIRST-20 }
                                                                                        >  1040  enum : uint { NM_RDOWN = NM_FIRST-21 }
                                                                                        >  1041  enum : uint { NM_THEMECHANGED = NM_FIRST-22 }
                                                                                        >  1042  // #endif
                                                                                        >  1043  
                                                                                        >  1044  // #ifndef CCSIZEOF_STRUCT
                                                                                        >  1045  // #define CCSIZEOF_STRUCT(structname, member) (((int)((LPBYTE)(&((structname*)0
                                                                                        >  1046  // #endif
                                                                                        >  1047  
                                                                                        >  1048  // #if (_WIN32_IE >= 0x0401)
                                                                                        >  1049  struct tagNMTOOLTIPSCREATED {
                                                                                        >  1050    NMHDR hdr;
                                                                                        >  1051    HWND hwndToolTips;
                                                                                        >  1052  }
                                                                                        >  1053  alias tagNMTOOLTIPSCREATED NMTOOLTIPSCREATED;
                                                                                        >  1054  alias tagNMTOOLTIPSCREATED* LPNMTOOLTIPSCREATED;
                                                                                        >  1055  
                                                                                        >  1056  // #endif
                                                                                        >  1057  
                                                                                        >  1058  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1059  struct tagNMMOUSE {
                                                                                        >  1060    NMHDR hdr;
                                                                                        >  1061    DWORD_PTR dwItemSpec;
                                                                                        >  1062    DWORD_PTR dwItemData;
                                                                                        >  1063    POINT pt;
                                                                                        >  1064    LPARAM dwHitInfo;
                                                                                        >  1065  }
                                                                                        >  1066  alias tagNMMOUSE NMMOUSE;
                                                                                        >  1067  alias tagNMMOUSE* LPNMMOUSE;
                                                                                        >  1068  
                                                                                        >  1069  alias NMMOUSE NMCLICK;
                                                                                        >  1070  alias LPNMMOUSE LPNMCLICK;
                                                                                        >  1071  
                                                                                        >  1072  struct tagNMOBJECTNOTIFY {
                                                                                        >  1073    NMHDR hdr;
                                                                                        >  1074    int iItem;
                                                                                        >  1075  // #ifdef __IID_DEFINED__
                                                                                        >  1076    IID* piid;
                                                                                        >  1077  // #else
                                                                                        >  1078  // ...
                                                                                        >  1079  // #endif
                                                                                        >  1080    void *pObject;
                                                                                        >  1081    HRESULT hResult;
                                                                                        >  1082    DWORD dwFlags;
                                                                                        >  1083  }
                                                                                        >  1084  alias tagNMOBJECTNOTIFY NMOBJECTNOTIFY;
                                                                                        >  1085  alias tagNMOBJECTNOTIFY* LPNMOBJECTNOTIFY;
                                                                                        >  1086  
                                                                                        >  1087  struct tagNMKEY {
                                                                                        >  1088    NMHDR hdr;
                                                                                        >  1089    UINT nVKey;
                                                                                        >  1090    UINT uFlags;
                                                                                        >  1091  }
                                                                                        >  1092  alias tagNMKEY NMKEY;
                                                                                        >  1093  alias tagNMKEY* LPNMKEY;
                                                                                        >  1094  
                                                                                        >  1095  struct tagNMCHAR {
                                                                                        >  1096    NMHDR hdr;
                                                                                        >  1097    UINT ch;
                                                                                        >  1098    DWORD dwItemPrev;
                                                                                        >  1099    DWORD dwItemNext;
                                                                                        >  1100  }
                                                                                        >  1101  alias tagNMCHAR NMCHAR;
                                                                                        >  1102  alias tagNMCHAR* LPNMCHAR;
                                                                                        >  1103  
                                                                                        >  1104  // #endif           // _WIN32_IE >= 0x0400
                                                                                        >  1105  
                                                                                        >  1106  // #define NM_FIRST (0U- 0U)
                                                                                        >  1107  enum : uint { NM_LAST = 0U- 99U }
                                                                                        >  1108  
                                                                                        >  1109  enum : uint { LVN_FIRST = 0U-100U }
                                                                                        >  1110  enum : uint { LVN_LAST = 0U-199U }
                                                                                        >  1111  
                                                                                        >  1112  enum : uint { HDN_FIRST = 0U-300U }
                                                                                        >  1113  enum : uint { HDN_LAST = 0U-399U }
                                                                                        >  1114  
                                                                                        >  1115  enum : uint { TVN_FIRST = 0U-400U }
                                                                                        >  1116  enum : uint { TVN_LAST = 0U-499U }
                                                                                        >  1117  
                                                                                        >  1118  enum : uint { TTN_FIRST = 0U-520U }
                                                                                        >  1119  enum : uint { TTN_LAST = 0U-549U }
                                                                                        >  1120  
                                                                                        >  1121  enum : uint { TCN_FIRST = 0U-550U }
                                                                                        >  1122  enum : uint { TCN_LAST = 0U-580U }
                                                                                        >  1123  
                                                                                        >  1124  enum : uint { CDN_FIRST = 0U-601U }
                                                                                        >  1125  enum : uint { CDN_LAST = 0U-699U }
                                                                                        >  1126  
                                                                                        >  1127  enum : uint { TBN_FIRST = 0U-700U }
                                                                                        >  1128  enum : uint { TBN_LAST = 0U-720U }
                                                                                        >  1129  
                                                                                        >  1130  enum : uint { UDN_FIRST = 0U-721 }
                                                                                        >  1131  enum : uint { UDN_LAST = 0U-740 }
                                                                                        >  1132  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1133  enum : uint { MCN_FIRST = 0U-750U }
                                                                                        >  1134  enum : uint { MCN_LAST = 0U-759U }
                                                                                        >  1135  
                                                                                        >  1136  enum : uint { DTN_FIRST = 0U-760U }
                                                                                        >  1137  enum : uint { DTN_LAST = 0U-799U }
                                                                                        >  1138  
                                                                                        >  1139  // #define CBEN_FIRST (0U-800U)
                                                                                        >  1140  enum : uint { CBEN_LAST = 0U-830U }
                                                                                        >  1141  
                                                                                        >  1142  enum : uint { RBN_FIRST = 0U-831U }
                                                                                        >  1143  enum : uint { RBN_LAST = 0U-859U }
                                                                                        >  1144  // #endif
                                                                                        >  1145  
                                                                                        >  1146  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1147  enum : uint { IPN_FIRST = 0U-860U }
                                                                                        >  1148  enum : uint { IPN_LAST = 0U-879U }
                                                                                        >  1149  
                                                                                        >  1150  enum : uint { SBN_FIRST = 0U-880U }
                                                                                        >  1151  enum : uint { SBN_LAST = 0U-899U }
                                                                                        >  1152  
                                                                                        >  1153  enum : uint { PGN_FIRST = 0U-900U }
                                                                                        >  1154  enum : uint { PGN_LAST = 0U-950U }
                                                                                        >  1155  
                                                                                        >  1156  // #endif
                                                                                        >  1157  
                                                                                        >  1158  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1159  // #ifndef WMN_FIRST
                                                                                        >  1160  enum : uint { WMN_FIRST = 0U-1000U }
                                                                                        >  1161  enum : uint { WMN_LAST = 0U-1200U }
                                                                                        >  1162  // #endif
                                                                                        >  1163  // #endif
                                                                                        >  1164  
                                                                                        >  1165  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  1166  enum : uint { BCN_FIRST = 0U-1250U }
                                                                                        >  1167  enum : uint { BCN_LAST = 0U-1350U }
                                                                                        >  1168  // #endif
                                                                                        >  1169  
                                                                                        >  1170  enum : uint { MSGF_COMMCTRL_BEGINDRAG = 0x4200 }
                                                                                        >  1171  enum : uint { MSGF_COMMCTRL_SIZEHEADER = 0x4201 }
                                                                                        >  1172  enum : uint { MSGF_COMMCTRL_DRAGSELECT = 0x4202 }
                                                                                        >  1173  enum : uint { MSGF_COMMCTRL_TOOLBARCUST = 0x4203 }
                                                                                        >  1174  
                                                                                        >  1175  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1176  
                                                                                        >  1177  enum : uint { CDRF_DODEFAULT = 0x00000000 }
                                                                                        >  1178  enum : uint { CDRF_NEWFONT = 0x00000002 }
                                                                                        >  1179  enum : uint { CDRF_SKIPDEFAULT = 0x00000004 }
                                                                                        >  1180  
                                                                                        >  1181  enum : uint { CDRF_NOTIFYPOSTPAINT = 0x00000010 }
                                                                                        >  1182  enum : uint { CDRF_NOTIFYITEMDRAW = 0x00000020 }
                                                                                        >  1183  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1184  enum : uint { CDRF_NOTIFYSUBITEMDRAW = 0x00000020 }
                                                                                        >  1185  // #endif
                                                                                        >  1186  enum : uint { CDRF_NOTIFYPOSTERASE = 0x00000040 }
                                                                                        >  1187  
                                                                                        >  1188  enum : uint { CDDS_PREPAINT = 0x00000001 }
                                                                                        >  1189  enum : uint { CDDS_POSTPAINT = 0x00000002 }
                                                                                        >  1190  enum : uint { CDDS_PREERASE = 0x00000003 }
                                                                                        >  1191  enum : uint { CDDS_POSTERASE = 0x00000004 }
                                                                                        >  1192  
                                                                                        >  1193  enum : uint { CDDS_ITEM = 0x00010000 }
                                                                                        >  1194  enum : uint { CDDS_ITEMPREPAINT = CDDS_ITEM | CDDS_PREPAINT }
                                                                                        >  1195  enum : uint { CDDS_ITEMPOSTPAINT = CDDS_ITEM | CDDS_POSTPAINT }
                                                                                        >  1196  enum : uint { CDDS_ITEMPREERASE = CDDS_ITEM | CDDS_PREERASE }
                                                                                        >  1197  enum : uint { CDDS_ITEMPOSTERASE = CDDS_ITEM | CDDS_POSTERASE }
                                                                                        >  1198  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1199  enum : uint { CDDS_SUBITEM = 0x00020000 }
                                                                                        >  1200  // #endif
                                                                                        >  1201  
                                                                                        >  1202  enum : uint { CDIS_SELECTED = 0x0001 }
                                                                                        >  1203  enum : uint { CDIS_GRAYED = 0x0002 }
                                                                                        >  1204  enum : uint { CDIS_DISABLED = 0x0004 }
                                                                                        >  1205  enum : uint { CDIS_CHECKED = 0x0008 }
                                                                                        >  1206  enum : uint { CDIS_FOCUS = 0x0010 }
                                                                                        >  1207  enum : uint { CDIS_DEFAULT = 0x0020 }
                                                                                        >  1208  enum : uint { CDIS_HOT = 0x0040 }
                                                                                        >  1209  enum : uint { CDIS_MARKED = 0x0080 }
                                                                                        >  1210  enum : uint { CDIS_INDETERMINATE = 0x0100 }
                                                                                        >  1211  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1212  enum : uint { CDIS_SHOWKEYBOARDCUES = 0x0200 }
                                                                                        >  1213  // #endif
                                                                                        >  1214  
                                                                                        >  1215  struct tagNMCUSTOMDRAWINFO {
                                                                                        >  1216    NMHDR hdr;
                                                                                        >  1217    DWORD dwDrawStage;
                                                                                        >  1218    HDC hdc;
                                                                                        >  1219    RECT rc;
                                                                                        >  1220    DWORD_PTR dwItemSpec;
                                                                                        >  1221    UINT uItemState;
                                                                                        >  1222    LPARAM lItemlParam;
                                                                                        >  1223  }
                                                                                        >  1224  alias tagNMCUSTOMDRAWINFO NMCUSTOMDRAW;
                                                                                        >  1225  alias tagNMCUSTOMDRAWINFO* LPNMCUSTOMDRAW;
                                                                                        >  1226  
                                                                                        >  1227  struct tagNMTTCUSTOMDRAW {
                                                                                        >  1228    NMCUSTOMDRAW nmcd;
                                                                                        >  1229    UINT uDrawFlags;
                                                                                        >  1230  }
                                                                                        >  1231  alias tagNMTTCUSTOMDRAW NMTTCUSTOMDRAW;
                                                                                        >  1232  alias tagNMTTCUSTOMDRAW* LPNMTTCUSTOMDRAW;
                                                                                        >  1233  
                                                                                        >  1234  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  1235  
                                                                                        >  1236  // #ifndef NOIMAGEAPIS
                                                                                        >  1237  
                                                                                        >  1238  enum : uint { CLR_NONE = 0xFFFFFFFF }
                                                                                        >  1239  enum : uint { CLR_DEFAULT = 0xFF000000 }
                                                                                        >  1240  
                                                                                        >  1241  // #ifndef HIMAGELIST
                                                                                        >  1242  // struct _IMAGELIST;
                                                                                        >  1243  alias _IMAGELIST* HIMAGELIST;
                                                                                        >  1244  // #endif
                                                                                        >  1245  
                                                                                        >  1246  // #ifndef IMAGELISTDRAWPARAMS
                                                                                        >  1247  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1248  struct _IMAGELISTDRAWPARAMS {
                                                                                        >  1249    DWORD cbSize;
                                                                                        >  1250    HIMAGELIST himl;
                                                                                        >  1251    int i;
                                                                                        >  1252    HDC hdcDst;
                                                                                        >  1253    int x;
                                                                                        >  1254    int y;
                                                                                        >  1255    int cx;
                                                                                        >  1256    int cy;
                                                                                        >  1257    int xBitmap;
                                                                                        >  1258    int yBitmap;
                                                                                        >  1259    COLORREF rgbBk;
                                                                                        >  1260    COLORREF rgbFg;
                                                                                        >  1261    UINT fStyle;
                                                                                        >  1262    DWORD dwRop;
                                                                                        >  1263  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1264    DWORD fState;
                                                                                        >  1265    DWORD Frame;
                                                                                        >  1266    COLORREF crEffect;
                                                                                        >  1267  // #endif
                                                                                        >  1268  }
                                                                                        >  1269  alias _IMAGELISTDRAWPARAMS IMAGELISTDRAWPARAMS;
                                                                                        >  1270  alias _IMAGELISTDRAWPARAMS* LPIMAGELISTDRAWPARAMS;
                                                                                        >  1271  
                                                                                        >  1272  // #define IMAGELISTDRAWPARAMS_V3_SIZE CCSIZEOF_STRUCT(IMAGELISTDRAWPARAMS, dwRo
                                                                                        >  1273  
                                                                                        >  1274  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  1275  // #endif
                                                                                        >  1276  
                                                                                        >  1277  enum : uint { ILC_MASK = 0x00000001 }
                                                                                        >  1278  enum : uint { ILC_COLOR = 0x00000000 }
                                                                                        >  1279  enum : uint { ILC_COLORDDB = 0x000000FE }
                                                                                        >  1280  enum : uint { ILC_COLOR4 = 0x00000004 }
                                                                                        >  1281  enum : uint { ILC_COLOR8 = 0x00000008 }
                                                                                        >  1282  enum : uint { ILC_COLOR16 = 0x00000010 }
                                                                                        >  1283  enum : uint { ILC_COLOR24 = 0x00000018 }
                                                                                        >  1284  enum : uint { ILC_COLOR32 = 0x00000020 }
                                                                                        >  1285  enum : uint { ILC_PALETTE = 0x00000800 }
                                                                                        >  1286  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1287  enum : uint { ILC_MIRROR = 0x00002000 }
                                                                                        >  1288  enum : uint { ILC_PERITEMMIRROR = 0x00008000 }
                                                                                        >  1289  // #endif
                                                                                        >  1290  extern(Windows) export HIMAGELIST ImageList_Create(int cx, int cy, UINT flags, i
                                                                                        >  1291  extern(Windows) export BOOL ImageList_Destroy(HIMAGELIST himl);
                                                                                        >  1292  
                                                                                        >  1293  extern(Windows) export int ImageList_GetImageCount(HIMAGELIST himl);
                                                                                        >  1294  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1295  extern(Windows) export BOOL ImageList_SetImageCount(HIMAGELIST himl, UINT uNewCo
                                                                                        >  1296  // #endif
                                                                                        >  1297  
                                                                                        >  1298  extern(Windows) export int ImageList_Add(HIMAGELIST himl, HBITMAP hbmImage, HBIT
                                                                                        >  1299  
                                                                                        >  1300  extern(Windows) export int ImageList_ReplaceIcon(HIMAGELIST himl, int i, HICON h
                                                                                        >  1301  extern(Windows) export COLORREF ImageList_SetBkColor(HIMAGELIST himl, COLORREF c
                                                                                        >  1302  extern(Windows) export COLORREF ImageList_GetBkColor(HIMAGELIST himl);
                                                                                        >  1303  extern(Windows) export BOOL ImageList_SetOverlayImage(HIMAGELIST himl, int iImag
                                                                                        >  1304  
                                                                                        >  1305  // #define ImageList_AddIcon(himl, hicon) ImageList_ReplaceIcon(himl, -1, hicon)
                                                                                        >  1306  
                                                                                        >  1307  enum : uint { ILD_NORMAL = 0x00000000 }
                                                                                        >  1308  enum : uint { ILD_TRANSPARENT = 0x00000001 }
                                                                                        >  1309  enum : uint { ILD_MASK = 0x00000010 }
                                                                                        >  1310  enum : uint { ILD_IMAGE = 0x00000020 }
                                                                                        >  1311  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1312  enum : uint { ILD_ROP = 0x00000040 }
                                                                                        >  1313  // #endif
                                                                                        >  1314  enum : uint { ILD_BLEND25 = 0x00000002 }
                                                                                        >  1315  enum : uint { ILD_BLEND50 = 0x00000004 }
                                                                                        >  1316  enum : uint { ILD_OVERLAYMASK = 0x00000F00 }
                                                                                        >  1317  uint INDEXTOOVERLAYMASK(uint i){ return i << 8; }
                                                                                        >  1318  enum : uint { ILD_PRESERVEALPHA = 0x00001000 }
                                                                                        >  1319  enum : uint { ILD_SCALE = 0x00002000 }
                                                                                        >  1320  enum : uint { ILD_DPISCALE = 0x00004000 }
                                                                                        >  1321  
                                                                                        >  1322  alias ILD_BLEND50 ILD_SELECTED;
                                                                                        >  1323  alias ILD_BLEND25 ILD_FOCUS;
                                                                                        >  1324  alias ILD_BLEND50 ILD_BLEND;
                                                                                        >  1325  alias CLR_DEFAULT CLR_HILIGHT;
                                                                                        >  1326  
                                                                                        >  1327  enum : uint { ILS_NORMAL = 0x00000000 }
                                                                                        >  1328  enum : uint { ILS_GLOW = 0x00000001 }
                                                                                        >  1329  enum : uint { ILS_SHADOW = 0x00000002 }
                                                                                        >  1330  enum : uint { ILS_SATURATE = 0x00000004 }
                                                                                        >  1331  enum : uint { ILS_ALPHA = 0x00000008 }
                                                                                        >  1332  
                                                                                        >  1333  extern(Windows) export BOOL ImageList_Draw(HIMAGELIST himl, int i, HDC hdcDst, i
                                                                                        >  1334  
                                                                                        >  1335  // #ifdef _WIN32
                                                                                        >  1336  
                                                                                        >  1337  extern(Windows) export BOOL ImageList_Replace(HIMAGELIST himl, int i, HBITMAP hb
                                                                                        >  1338  
                                                                                        >  1339  extern(Windows) export int ImageList_AddMasked(HIMAGELIST himl, HBITMAP hbmImage
                                                                                        >  1340  extern(Windows) export BOOL ImageList_DrawEx(HIMAGELIST himl, int i, HDC hdcDst,
                                                                                        >  1341  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1342  extern(Windows) export BOOL ImageList_DrawIndirect(IMAGELISTDRAWPARAMS* pimldp);
                                                                                        >  1343  // #endif
                                                                                        >  1344  extern(Windows) export BOOL ImageList_Remove(HIMAGELIST himl, int i);
                                                                                        >  1345  extern(Windows) export HICON ImageList_GetIcon(HIMAGELIST himl, int i, UINT flag
                                                                                        >  1346  extern(Windows) export HIMAGELIST ImageList_LoadImageA(HINSTANCE hi, LPCSTR lpbm
                                                                                        >  1347  extern(Windows) export HIMAGELIST ImageList_LoadImageW(HINSTANCE hi, LPCWSTR lpb
                                                                                        >  1348  
                                                                                        >  1349  // #ifdef UNICODE
                                                                                        >  1350  // #...
                                                                                        >  1351  // #else
                                                                                        >  1352  alias ImageList_LoadImageA ImageList_LoadImage;
                                                                                        >  1353  // #endif
                                                                                        >  1354  
                                                                                        >  1355  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1356  enum : uint { ILCF_MOVE = 0x00000000 }
                                                                                        >  1357  enum : uint { ILCF_SWAP = 0x00000001 }
                                                                                        >  1358  extern(Windows) export BOOL ImageList_Copy(HIMAGELIST himlDst, int iDst, HIMAGEL
                                                                                        >  1359  // #endif
                                                                                        >  1360  
                                                                                        >  1361  extern(Windows) export BOOL ImageList_BeginDrag(HIMAGELIST himlTrack, int iTrack
                                                                                        >  1362  extern(Windows) export void ImageList_EndDrag();
                                                                                        >  1363  extern(Windows) export BOOL ImageList_DragEnter(HWND hwndLock, int x, int y);
                                                                                        >  1364  extern(Windows) export BOOL ImageList_DragLeave(HWND hwndLock);
                                                                                        >  1365  extern(Windows) export BOOL ImageList_DragMove(int x, int y);
                                                                                        >  1366  extern(Windows) export BOOL ImageList_SetDragCursorImage(HIMAGELIST himlDrag, in
                                                                                        >  1367  
                                                                                        >  1368  extern(Windows) export BOOL ImageList_DragShowNolock(BOOL fShow);
                                                                                        >  1369  extern(Windows) export HIMAGELIST ImageList_GetDragImage(POINT *ppt,POINT *pptHo
                                                                                        >  1370  
                                                                                        >  1371  // #define ImageList_RemoveAll(himl) ImageList_Remove(himl, -1)
                                                                                        >  1372  // #define ImageList_ExtractIcon(hi, himl, i) ImageList_GetIcon(himl, i, 0)
                                                                                        >  1373  // #define ImageList_LoadBitmap(hi, lpbmp, cx, cGrow, crMask) ImageList_LoadImag
                                                                                        >  1374  
                                                                                        >  1375  // #ifdef __IStream_INTERFACE_DEFINED__
                                                                                        >  1376  
                                                                                        >  1377  // ...
                                                                                        >  1378  
                                                                                        >  1379  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  1380  // #...
                                                                                        >  1381  // #...
                                                                                        >  1382  
                                                                                        >  1383  // ...
                                                                                        >  1384  // #endif
                                                                                        >  1385  
                                                                                        >  1386  // #endif
                                                                                        >  1387  
                                                                                        >  1388  // #ifndef IMAGEINFO
                                                                                        >  1389  struct _IMAGEINFO {
                                                                                        >  1390    HBITMAP hbmImage;
                                                                                        >  1391    HBITMAP hbmMask;
                                                                                        >  1392    int Unused1;
                                                                                        >  1393    int Unused2;
                                                                                        >  1394    RECT rcImage;
                                                                                        >  1395  }
                                                                                        >  1396  alias _IMAGEINFO IMAGEINFO;
                                                                                        >  1397  alias _IMAGEINFO* LPIMAGEINFO;
                                                                                        >  1398  
                                                                                        >  1399  // #endif
                                                                                        >  1400  
                                                                                        >  1401  extern(Windows) export BOOL ImageList_GetIconSize(HIMAGELIST himl, int *cx, int 
                                                                                        >  1402  extern(Windows) export BOOL ImageList_SetIconSize(HIMAGELIST himl, int cx, int c
                                                                                        >  1403  extern(Windows) export BOOL ImageList_GetImageInfo(HIMAGELIST himl, int i, IMAGE
                                                                                        >  1404  extern(Windows) export HIMAGELIST ImageList_Merge(HIMAGELIST himl1, int i1, HIMA
                                                                                        >  1405  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1406  extern(Windows) export HIMAGELIST ImageList_Duplicate(HIMAGELIST himl);
                                                                                        >  1407  // #endif
                                                                                        >  1408  
                                                                                        >  1409  // #endif
                                                                                        >  1410  
                                                                                        >  1411  // #endif
                                                                                        >  1412  
                                                                                        >  1413  // #ifndef NOHEADER
                                                                                        >  1414  
                                                                                        >  1415  // #ifdef _WIN32
                                                                                        >  1416  const char[] WC_HEADERA = "SysHeader32";
                                                                                        >  1417  const wchar[] WC_HEADERW = "SysHeader32";
                                                                                        >  1418  
                                                                                        >  1419  // #ifdef UNICODE
                                                                                        >  1420  // #...
                                                                                        >  1421  // #else
                                                                                        >  1422  alias WC_HEADERA WC_HEADER;
                                                                                        >  1423  // #endif
                                                                                        >  1424  
                                                                                        >  1425  // #else
                                                                                        >  1426  // #...
                                                                                        >  1427  // #endif
                                                                                        >  1428  
                                                                                        >  1429  enum : uint { HDS_HORZ = 0x0000 }
                                                                                        >  1430  enum : uint { HDS_BUTTONS = 0x0002 }
                                                                                        >  1431  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1432  enum : uint { HDS_HOTTRACK = 0x0004 }
                                                                                        >  1433  // #endif
                                                                                        >  1434  enum : uint { HDS_HIDDEN = 0x0008 }
                                                                                        >  1435  
                                                                                        >  1436  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1437  enum : uint { HDS_DRAGDROP = 0x0040 }
                                                                                        >  1438  enum : uint { HDS_FULLDRAG = 0x0080 }
                                                                                        >  1439  // #endif
                                                                                        >  1440  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1441  enum : uint { HDS_FILTERBAR = 0x0100 }
                                                                                        >  1442  // #endif
                                                                                        >  1443  
                                                                                        >  1444  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1445  enum : uint { HDS_FLAT = 0x0200 }
                                                                                        >  1446  // #endif
                                                                                        >  1447  
                                                                                        >  1448  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1449  
                                                                                        >  1450  enum : uint { HDFT_ISSTRING = 0x0000 }
                                                                                        >  1451  enum : uint { HDFT_ISNUMBER = 0x0001 }
                                                                                        >  1452  
                                                                                        >  1453  enum : uint { HDFT_HASNOVALUE = 0x8000 }
                                                                                        >  1454  
                                                                                        >  1455  // #ifdef UNICODE
                                                                                        >  1456  // #...
                                                                                        >  1457  // #...
                                                                                        >  1458  // #...
                                                                                        >  1459  // #...
                                                                                        >  1460  // #else
                                                                                        >  1461  alias HD_TEXTFILTERA HD_TEXTFILTER;
                                                                                        >  1462  alias HD_TEXTFILTERA HDTEXTFILTER;
                                                                                        >  1463  alias LPHD_TEXTFILTERA LPHD_TEXTFILTER;
                                                                                        >  1464  alias LPHD_TEXTFILTERA LPHDTEXTFILTER;
                                                                                        >  1465  // #endif
                                                                                        >  1466  
                                                                                        >  1467  struct _HD_TEXTFILTERA {
                                                                                        >  1468    LPSTR pszText;
                                                                                        >  1469    INT cchTextMax;
                                                                                        >  1470  }
                                                                                        >  1471  alias _HD_TEXTFILTERA HD_TEXTFILTERA;
                                                                                        >  1472  alias _HD_TEXTFILTERA* LPHD_TEXTFILTERA;
                                                                                        >  1473  
                                                                                        >  1474  struct _HD_TEXTFILTERW {
                                                                                        >  1475    LPWSTR pszText;
                                                                                        >  1476    INT cchTextMax;
                                                                                        >  1477  }
                                                                                        >  1478  alias _HD_TEXTFILTERW HD_TEXTFILTERW;
                                                                                        >  1479  alias _HD_TEXTFILTERW* LPHD_TEXTFILTERW;
                                                                                        >  1480  
                                                                                        >  1481  // #endif  // _WIN32_IE >= 0x0500
                                                                                        >  1482  
                                                                                        >  1483  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1484  alias HDITEMA HD_ITEMA;
                                                                                        >  1485  alias HDITEMW HD_ITEMW;
                                                                                        >  1486  // #else
                                                                                        >  1487  // #...
                                                                                        >  1488  // #...
                                                                                        >  1489  // #endif
                                                                                        >  1490  alias HDITEM HD_ITEM;
                                                                                        >  1491  
                                                                                        >  1492  struct _HD_ITEMA {
                                                                                        >  1493    UINT mask;
                                                                                        >  1494    int cxy;
                                                                                        >  1495    LPSTR pszText;
                                                                                        >  1496    HBITMAP hbm;
                                                                                        >  1497    int cchTextMax;
                                                                                        >  1498    int fmt;
                                                                                        >  1499    LPARAM lParam;
                                                                                        >  1500  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1501    int iImage;
                                                                                        >  1502    int iOrder;
                                                                                        >  1503  // #endif
                                                                                        >  1504  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1505    UINT type;
                                                                                        >  1506    void *  pvFilter;
                                                                                        >  1507  // #endif
                                                                                        >  1508  }
                                                                                        >  1509  alias _HD_ITEMA HDITEMA;
                                                                                        >  1510  alias _HD_ITEMA* LPHDITEMA;
                                                                                        >  1511  
                                                                                        >  1512  // #define HDITEMA_V1_SIZE CCSIZEOF_STRUCT(HDITEMA, lParam)
                                                                                        >  1513  // #define HDITEMW_V1_SIZE CCSIZEOF_STRUCT(HDITEMW, lParam)
                                                                                        >  1514  
                                                                                        >  1515  struct _HD_ITEMW {
                                                                                        >  1516    UINT mask;
                                                                                        >  1517    int cxy;
                                                                                        >  1518    LPWSTR pszText;
                                                                                        >  1519    HBITMAP hbm;
                                                                                        >  1520    int cchTextMax;
                                                                                        >  1521    int fmt;
                                                                                        >  1522    LPARAM lParam;
                                                                                        >  1523  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1524    int iImage;
                                                                                        >  1525    int iOrder;
                                                                                        >  1526  // #endif
                                                                                        >  1527  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1528    UINT type;
                                                                                        >  1529    void *  pvFilter;
                                                                                        >  1530  // #endif
                                                                                        >  1531  }
                                                                                        >  1532  alias _HD_ITEMW HDITEMW;
                                                                                        >  1533  alias _HD_ITEMW* LPHDITEMW;
                                                                                        >  1534  
                                                                                        >  1535  // #ifdef UNICODE
                                                                                        >  1536  // #...
                                                                                        >  1537  // #...
                                                                                        >  1538  // #...
                                                                                        >  1539  // #else
                                                                                        >  1540  alias HDITEMA HDITEM;
                                                                                        >  1541  alias LPHDITEMA LPHDITEM;
                                                                                        >  1542  // #define HDITEM_V1_SIZE HDITEMA_V1_SIZE
                                                                                        >  1543  // #endif
                                                                                        >  1544  
                                                                                        >  1545  enum : uint { HDI_WIDTH = 0x0001 }
                                                                                        >  1546  alias HDI_WIDTH HDI_HEIGHT;
                                                                                        >  1547  enum : uint { HDI_TEXT = 0x0002 }
                                                                                        >  1548  enum : uint { HDI_FORMAT = 0x0004 }
                                                                                        >  1549  enum : uint { HDI_LPARAM = 0x0008 }
                                                                                        >  1550  enum : uint { HDI_BITMAP = 0x0010 }
                                                                                        >  1551  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1552  enum : uint { HDI_IMAGE = 0x0020 }
                                                                                        >  1553  enum : uint { HDI_DI_SETITEM = 0x0040 }
                                                                                        >  1554  enum : uint { HDI_ORDER = 0x0080 }
                                                                                        >  1555  // #endif
                                                                                        >  1556  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1557  enum : uint { HDI_FILTER = 0x0100 }
                                                                                        >  1558  // #endif
                                                                                        >  1559  
                                                                                        >  1560  enum : uint { HDF_LEFT = 0x0000 }
                                                                                        >  1561  enum : uint { HDF_RIGHT = 0x0001 }
                                                                                        >  1562  enum : uint { HDF_CENTER = 0x0002 }
                                                                                        >  1563  enum : uint { HDF_JUSTIFYMASK = 0x0003 }
                                                                                        >  1564  enum : uint { HDF_RTLREADING = 0x0004 }
                                                                                        >  1565  
                                                                                        >  1566  enum : uint { HDF_OWNERDRAW = 0x8000 }
                                                                                        >  1567  enum : uint { HDF_STRING = 0x4000 }
                                                                                        >  1568  enum : uint { HDF_BITMAP = 0x2000 }
                                                                                        >  1569  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1570  enum : uint { HDF_BITMAP_ON_RIGHT = 0x1000 }
                                                                                        >  1571  enum : uint { HDF_IMAGE = 0x0800 }
                                                                                        >  1572  // #endif
                                                                                        >  1573  
                                                                                        >  1574  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1575  enum : uint { HDF_SORTUP = 0x0400 }
                                                                                        >  1576  enum : uint { HDF_SORTDOWN = 0x0200 }
                                                                                        >  1577  // #endif
                                                                                        >  1578  
                                                                                        >  1579  enum : uint { HDM_GETITEMCOUNT = HDM_FIRST + 0 }
                                                                                        >  1580  // #define Header_GetItemCount(hwndHD) (int)SNDMSG((hwndHD), HDM_GETITEMCOUNT, 0
                                                                                        >  1581  
                                                                                        >  1582  enum : uint { HDM_INSERTITEMA = HDM_FIRST + 1 }
                                                                                        >  1583  enum : uint { HDM_INSERTITEMW = HDM_FIRST + 10 }
                                                                                        >  1584  
                                                                                        >  1585  // #ifdef UNICODE
                                                                                        >  1586  // #...
                                                                                        >  1587  // #else
                                                                                        >  1588  alias HDM_INSERTITEMA HDM_INSERTITEM;
                                                                                        >  1589  // #endif
                                                                                        >  1590  
                                                                                        >  1591  // #define Header_InsertItem(hwndHD, i, phdi) (int)SNDMSG((hwndHD), HDM_INSERTIT
                                                                                        >  1592  
                                                                                        >  1593  enum : uint { HDM_DELETEITEM = HDM_FIRST + 2 }
                                                                                        >  1594  // #define Header_DeleteItem(hwndHD, i) (BOOL)SNDMSG((hwndHD), HDM_DELETEITEM, (
                                                                                        >  1595  
                                                                                        >  1596  enum : uint { HDM_GETITEMA = HDM_FIRST + 3 }
                                                                                        >  1597  enum : uint { HDM_GETITEMW = HDM_FIRST + 11 }
                                                                                        >  1598  
                                                                                        >  1599  // #ifdef UNICODE
                                                                                        >  1600  // #...
                                                                                        >  1601  // #else
                                                                                        >  1602  alias HDM_GETITEMA HDM_GETITEM;
                                                                                        >  1603  // #endif
                                                                                        >  1604  
                                                                                        >  1605  // #define Header_GetItem(hwndHD, i, phdi) (BOOL)SNDMSG((hwndHD), HDM_GETITEM, (
                                                                                        >  1606  
                                                                                        >  1607  enum : uint { HDM_SETITEMA = HDM_FIRST + 4 }
                                                                                        >  1608  enum : uint { HDM_SETITEMW = HDM_FIRST + 12 }
                                                                                        >  1609  
                                                                                        >  1610  // #ifdef UNICODE
                                                                                        >  1611  // #...
                                                                                        >  1612  // #else
                                                                                        >  1613  alias HDM_SETITEMA HDM_SETITEM;
                                                                                        >  1614  // #endif
                                                                                        >  1615  
                                                                                        >  1616  // #define Header_SetItem(hwndHD, i, phdi) (BOOL)SNDMSG((hwndHD), HDM_SETITEM, (
                                                                                        >  1617  
                                                                                        >  1618  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1619  alias HDLAYOUT HD_LAYOUT;
                                                                                        >  1620  // #else
                                                                                        >  1621  // #...
                                                                                        >  1622  // #endif
                                                                                        >  1623  
                                                                                        >  1624  struct _HD_LAYOUT {
                                                                                        >  1625    RECT *prc;
                                                                                        >  1626    WINDOWPOS *pwpos;
                                                                                        >  1627  }
                                                                                        >  1628  alias _HD_LAYOUT HDLAYOUT;
                                                                                        >  1629  alias _HD_LAYOUT* LPHDLAYOUT;
                                                                                        >  1630  
                                                                                        >  1631  enum : uint { HDM_LAYOUT = HDM_FIRST + 5 }
                                                                                        >  1632  // #define Header_Layout(hwndHD, playout) (BOOL)SNDMSG((hwndHD), HDM_LAYOUT, 0, 
                                                                                        >  1633  
                                                                                        >  1634  enum : uint { HHT_NOWHERE = 0x0001 }
                                                                                        >  1635  enum : uint { HHT_ONHEADER = 0x0002 }
                                                                                        >  1636  enum : uint { HHT_ONDIVIDER = 0x0004 }
                                                                                        >  1637  enum : uint { HHT_ONDIVOPEN = 0x0008 }
                                                                                        >  1638  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1639  enum : uint { HHT_ONFILTER = 0x0010 }
                                                                                        >  1640  enum : uint { HHT_ONFILTERBUTTON = 0x0020 }
                                                                                        >  1641  // #endif
                                                                                        >  1642  enum : uint { HHT_ABOVE = 0x0100 }
                                                                                        >  1643  enum : uint { HHT_BELOW = 0x0200 }
                                                                                        >  1644  enum : uint { HHT_TORIGHT = 0x0400 }
                                                                                        >  1645  enum : uint { HHT_TOLEFT = 0x0800 }
                                                                                        >  1646  
                                                                                        >  1647  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1648  alias HDHITTESTINFO HD_HITTESTINFO;
                                                                                        >  1649  // #else
                                                                                        >  1650  // #...
                                                                                        >  1651  // #endif
                                                                                        >  1652  
                                                                                        >  1653  struct _HD_HITTESTINFO {
                                                                                        >  1654    POINT pt;
                                                                                        >  1655    UINT flags;
                                                                                        >  1656    int iItem;
                                                                                        >  1657  }
                                                                                        >  1658  alias _HD_HITTESTINFO HDHITTESTINFO;
                                                                                        >  1659  alias _HD_HITTESTINFO* LPHDHITTESTINFO;
                                                                                        >  1660  
                                                                                        >  1661  enum : uint { HDM_HITTEST = HDM_FIRST + 6 }
                                                                                        >  1662  
                                                                                        >  1663  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1664  
                                                                                        >  1665  enum : uint { HDM_GETITEMRECT = HDM_FIRST + 7 }
                                                                                        >  1666  // #define Header_GetItemRect(hwnd, iItem, lprc) (BOOL)SNDMSG((hwnd), HDM_GETITE
                                                                                        >  1667  
                                                                                        >  1668  enum : uint { HDM_SETIMAGELIST = HDM_FIRST + 8 }
                                                                                        >  1669  // #define Header_SetImageList(hwnd, himl) (HIMAGELIST)SNDMSG((hwnd), HDM_SETIMA
                                                                                        >  1670  
                                                                                        >  1671  enum : uint { HDM_GETIMAGELIST = HDM_FIRST + 9 }
                                                                                        >  1672  // #define Header_GetImageList(hwnd) (HIMAGELIST)SNDMSG((hwnd), HDM_GETIMAGELIST
                                                                                        >  1673  
                                                                                        >  1674  enum : uint { HDM_ORDERTOINDEX = HDM_FIRST + 15 }
                                                                                        >  1675  // #define Header_OrderToIndex(hwnd, i) (int)SNDMSG((hwnd), HDM_ORDERTOINDEX, (W
                                                                                        >  1676  
                                                                                        >  1677  enum : uint { HDM_CREATEDRAGIMAGE = HDM_FIRST + 16 }
                                                                                        >  1678  // #define Header_CreateDragImage(hwnd, i) (HIMAGELIST)SNDMSG((hwnd), HDM_CREATE
                                                                                        >  1679  
                                                                                        >  1680  enum : uint { HDM_GETORDERARRAY = HDM_FIRST + 17 }
                                                                                        >  1681  // #define Header_GetOrderArray(hwnd, iCount, lpi) (BOOL)SNDMSG((hwnd), HDM_GETO
                                                                                        >  1682  
                                                                                        >  1683  enum : uint { HDM_SETORDERARRAY = HDM_FIRST + 18 }
                                                                                        >  1684  // #define Header_SetOrderArray(hwnd, iCount, lpi) (BOOL)SNDMSG((hwnd), HDM_SETO
                                                                                        >  1685  
                                                                                        >  1686  enum : uint { HDM_SETHOTDIVIDER = HDM_FIRST + 19 }
                                                                                        >  1687  // #define Header_SetHotDivider(hwnd, fPos, dw) (int)SNDMSG((hwnd), HDM_SETHOTDI
                                                                                        >  1688  
                                                                                        >  1689  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  1690  
                                                                                        >  1691  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1692  
                                                                                        >  1693  enum : uint { HDM_SETBITMAPMARGIN = HDM_FIRST + 20 }
                                                                                        >  1694  // #define Header_SetBitmapMargin(hwnd, iWidth) (int)SNDMSG((hwnd), HDM_SETBITMA
                                                                                        >  1695  
                                                                                        >  1696  enum : uint { HDM_GETBITMAPMARGIN = HDM_FIRST + 21 }
                                                                                        >  1697  // #define Header_GetBitmapMargin(hwnd) (int)SNDMSG((hwnd), HDM_GETBITMAPMARGIN,
                                                                                        >  1698  // #endif
                                                                                        >  1699  
                                                                                        >  1700  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1701  alias CCM_SETUNICODEFORMAT HDM_SETUNICODEFORMAT;
                                                                                        >  1702  // #define Header_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), HDM_SETU
                                                                                        >  1703  
                                                                                        >  1704  alias CCM_GETUNICODEFORMAT HDM_GETUNICODEFORMAT;
                                                                                        >  1705  // #define Header_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), HDM_GETUNICODEFORM
                                                                                        >  1706  // #endif
                                                                                        >  1707  
                                                                                        >  1708  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1709  enum : uint { HDM_SETFILTERCHANGETIMEOUT = HDM_FIRST+22 }
                                                                                        >  1710  // #define Header_SetFilterChangeTimeout(hwnd, i) (int)SNDMSG((hwnd), HDM_SETFIL
                                                                                        >  1711  
                                                                                        >  1712  enum : uint { HDM_EDITFILTER = HDM_FIRST+23 }
                                                                                        >  1713  // #define Header_EditFilter(hwnd, i, fDiscardChanges) (int)SNDMSG((hwnd), HDM_E
                                                                                        >  1714  
                                                                                        >  1715  enum : uint { HDM_CLEARFILTER = HDM_FIRST+24 }
                                                                                        >  1716  // #define Header_ClearFilter(hwnd, i) (int)SNDMSG((hwnd), HDM_CLEARFILTER, (WPA
                                                                                        >  1717  // #define Header_ClearAllFilters(hwnd) (int)SNDMSG((hwnd), HDM_CLEARFILTER, (WP
                                                                                        >  1718  // #endif
                                                                                        >  1719  
                                                                                        >  1720  enum : uint { HDN_ITEMCHANGINGA = HDN_FIRST-0 }
                                                                                        >  1721  enum : uint { HDN_ITEMCHANGINGW = HDN_FIRST-20 }
                                                                                        >  1722  enum : uint { HDN_ITEMCHANGEDA = HDN_FIRST-1 }
                                                                                        >  1723  enum : uint { HDN_ITEMCHANGEDW = HDN_FIRST-21 }
                                                                                        >  1724  enum : uint { HDN_ITEMCLICKA = HDN_FIRST-2 }
                                                                                        >  1725  enum : uint { HDN_ITEMCLICKW = HDN_FIRST-22 }
                                                                                        >  1726  enum : uint { HDN_ITEMDBLCLICKA = HDN_FIRST-3 }
                                                                                        >  1727  enum : uint { HDN_ITEMDBLCLICKW = HDN_FIRST-23 }
                                                                                        >  1728  enum : uint { HDN_DIVIDERDBLCLICKA = HDN_FIRST-5 }
                                                                                        >  1729  enum : uint { HDN_DIVIDERDBLCLICKW = HDN_FIRST-25 }
                                                                                        >  1730  enum : uint { HDN_BEGINTRACKA = HDN_FIRST-6 }
                                                                                        >  1731  enum : uint { HDN_BEGINTRACKW = HDN_FIRST-26 }
                                                                                        >  1732  enum : uint { HDN_ENDTRACKA = HDN_FIRST-7 }
                                                                                        >  1733  enum : uint { HDN_ENDTRACKW = HDN_FIRST-27 }
                                                                                        >  1734  enum : uint { HDN_TRACKA = HDN_FIRST-8 }
                                                                                        >  1735  enum : uint { HDN_TRACKW = HDN_FIRST-28 }
                                                                                        >  1736  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1737  enum : uint { HDN_GETDISPINFOA = HDN_FIRST-9 }
                                                                                        >  1738  enum : uint { HDN_GETDISPINFOW = HDN_FIRST-29 }
                                                                                        >  1739  enum : uint { HDN_BEGINDRAG = HDN_FIRST-10 }
                                                                                        >  1740  enum : uint { HDN_ENDDRAG = HDN_FIRST-11 }
                                                                                        >  1741  // #endif
                                                                                        >  1742  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1743  enum : uint { HDN_FILTERCHANGE = HDN_FIRST-12 }
                                                                                        >  1744  enum : uint { HDN_FILTERBTNCLICK = HDN_FIRST-13 }
                                                                                        >  1745  // #endif
                                                                                        >  1746  
                                                                                        >  1747  // #ifdef UNICODE
                                                                                        >  1748  // #...
                                                                                        >  1749  // #...
                                                                                        >  1750  // #...
                                                                                        >  1751  // #...
                                                                                        >  1752  // #...
                                                                                        >  1753  // #...
                                                                                        >  1754  // #...
                                                                                        >  1755  // #...
                                                                                        >  1756  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1757  // #...
                                                                                        >  1758  // #endif
                                                                                        >  1759  // #else
                                                                                        >  1760  alias HDN_ITEMCHANGINGA HDN_ITEMCHANGING;
                                                                                        >  1761  alias HDN_ITEMCHANGEDA HDN_ITEMCHANGED;
                                                                                        >  1762  alias HDN_ITEMCLICKA HDN_ITEMCLICK;
                                                                                        >  1763  alias HDN_ITEMDBLCLICKA HDN_ITEMDBLCLICK;
                                                                                        >  1764  alias HDN_DIVIDERDBLCLICKA HDN_DIVIDERDBLCLICK;
                                                                                        >  1765  alias HDN_BEGINTRACKA HDN_BEGINTRACK;
                                                                                        >  1766  alias HDN_ENDTRACKA HDN_ENDTRACK;
                                                                                        >  1767  alias HDN_TRACKA HDN_TRACK;
                                                                                        >  1768  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1769  alias HDN_GETDISPINFOA HDN_GETDISPINFO;
                                                                                        >  1770  // #endif
                                                                                        >  1771  // #endif
                                                                                        >  1772  
                                                                                        >  1773  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1774  alias NMHEADERA HD_NOTIFYA;
                                                                                        >  1775  alias NMHEADERW HD_NOTIFYW;
                                                                                        >  1776  // #else
                                                                                        >  1777  // #...
                                                                                        >  1778  // #...
                                                                                        >  1779  // #...
                                                                                        >  1780  // #...
                                                                                        >  1781  // #endif
                                                                                        >  1782  alias NMHEADER HD_NOTIFY;
                                                                                        >  1783  
                                                                                        >  1784  struct tagNMHEADERA {
                                                                                        >  1785    NMHDR hdr;
                                                                                        >  1786    int iItem;
                                                                                        >  1787    int iButton;
                                                                                        >  1788    HDITEMA *pitem;
                                                                                        >  1789  }
                                                                                        >  1790  alias tagNMHEADERA NMHEADERA;
                                                                                        >  1791  alias tagNMHEADERA* LPNMHEADERA;
                                                                                        >  1792  
                                                                                        >  1793  struct tagNMHEADERW {
                                                                                        >  1794    NMHDR hdr;
                                                                                        >  1795    int iItem;
                                                                                        >  1796    int iButton;
                                                                                        >  1797    HDITEMW *pitem;
                                                                                        >  1798  }
                                                                                        >  1799  alias tagNMHEADERW NMHEADERW;
                                                                                        >  1800  alias tagNMHEADERW* LPNMHEADERW;
                                                                                        >  1801  
                                                                                        >  1802  // #ifdef UNICODE
                                                                                        >  1803  // #...
                                                                                        >  1804  // #...
                                                                                        >  1805  // #else
                                                                                        >  1806  alias NMHEADERA NMHEADER;
                                                                                        >  1807  alias LPNMHEADERA LPNMHEADER;
                                                                                        >  1808  // #endif
                                                                                        >  1809  
                                                                                        >  1810  struct tagNMHDDISPINFOW {
                                                                                        >  1811    NMHDR hdr;
                                                                                        >  1812    int iItem;
                                                                                        >  1813    UINT mask;
                                                                                        >  1814    LPWSTR pszText;
                                                                                        >  1815    int cchTextMax;
                                                                                        >  1816    int iImage;
                                                                                        >  1817    LPARAM lParam;
                                                                                        >  1818  }
                                                                                        >  1819  alias tagNMHDDISPINFOW NMHDDISPINFOW;
                                                                                        >  1820  alias tagNMHDDISPINFOW* LPNMHDDISPINFOW;
                                                                                        >  1821  
                                                                                        >  1822  struct tagNMHDDISPINFOA {
                                                                                        >  1823    NMHDR hdr;
                                                                                        >  1824    int iItem;
                                                                                        >  1825    UINT mask;
                                                                                        >  1826    LPSTR pszText;
                                                                                        >  1827    int cchTextMax;
                                                                                        >  1828    int iImage;
                                                                                        >  1829    LPARAM lParam;
                                                                                        >  1830  }
                                                                                        >  1831  alias tagNMHDDISPINFOA NMHDDISPINFOA;
                                                                                        >  1832  alias tagNMHDDISPINFOA* LPNMHDDISPINFOA;
                                                                                        >  1833  
                                                                                        >  1834  // #ifdef UNICODE
                                                                                        >  1835  // #...
                                                                                        >  1836  // #...
                                                                                        >  1837  // #else
                                                                                        >  1838  alias NMHDDISPINFOA NMHDDISPINFO;
                                                                                        >  1839  alias LPNMHDDISPINFOA LPNMHDDISPINFO;
                                                                                        >  1840  // #endif
                                                                                        >  1841  
                                                                                        >  1842  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1843  struct tagNMHDFILTERBTNCLICK {
                                                                                        >  1844    NMHDR hdr;
                                                                                        >  1845    INT iItem;
                                                                                        >  1846    RECT rc;
                                                                                        >  1847  }
                                                                                        >  1848  alias tagNMHDFILTERBTNCLICK NMHDFILTERBTNCLICK;
                                                                                        >  1849  alias tagNMHDFILTERBTNCLICK* LPNMHDFILTERBTNCLICK;
                                                                                        >  1850  
                                                                                        >  1851  // #endif
                                                                                        >  1852  
                                                                                        >  1853  // #endif      // NOHEADER
                                                                                        >  1854  
                                                                                        >  1855  // #ifndef NOTOOLBAR
                                                                                        >  1856  
                                                                                        >  1857  // #ifdef _WIN32
                                                                                        >  1858  const wchar[] TOOLBARCLASSNAMEW = "ToolbarWindow32";
                                                                                        >  1859  const char[] TOOLBARCLASSNAMEA = "ToolbarWindow32";
                                                                                        >  1860  
                                                                                        >  1861  // #ifdef  UNICODE
                                                                                        >  1862  // #...
                                                                                        >  1863  // #else
                                                                                        >  1864  alias TOOLBARCLASSNAMEA TOOLBARCLASSNAME;
                                                                                        >  1865  // #endif
                                                                                        >  1866  
                                                                                        >  1867  // #else
                                                                                        >  1868  // #...
                                                                                        >  1869  // #endif
                                                                                        >  1870  
                                                                                        >  1871  struct _TBBUTTON {
                                                                                        >  1872    int iBitmap;
                                                                                        >  1873    int idCommand;
                                                                                        >  1874    BYTE fsState;
                                                                                        >  1875    BYTE fsStyle;
                                                                                        >  1876  // #ifdef _WIN64
                                                                                        >  1877  // ...
                                                                                        >  1878  // #elif defined(_WIN32)
                                                                                        >  1879    BYTE bReserved[2];
                                                                                        >  1880  // #endif
                                                                                        >  1881    DWORD_PTR dwData;
                                                                                        >  1882    INT_PTR iString;
                                                                                        >  1883  }
                                                                                        >  1884  alias _TBBUTTON TBBUTTON;
                                                                                        >  1885  alias _TBBUTTON* PTBBUTTON;
                                                                                        >  1886  alias _TBBUTTON* LPTBBUTTON;
                                                                                        >  1887  
                                                                                        >  1888  alias TBBUTTON* LPCTBBUTTON;
                                                                                        >  1889  
                                                                                        >  1890  struct _COLORMAP {
                                                                                        >  1891    COLORREF from;
                                                                                        >  1892    COLORREF to;
                                                                                        >  1893  }
                                                                                        >  1894  alias _COLORMAP COLORMAP;
                                                                                        >  1895  alias _COLORMAP* LPCOLORMAP;
                                                                                        >  1896  
                                                                                        >  1897  extern(Windows) export HWND CreateToolbarEx(HWND hwnd, DWORD ws, UINT wID, int n
                                                                                        >  1898    HINSTANCE hBMInst, UINT_PTR wBMID, LPCTBBUTTON lpButtons,
                                                                                        >  1899    int iNumButtons, int dxButton, int dyButton,
                                                                                        >  1900    int dxBitmap, int dyBitmap, UINT uStructSize);
                                                                                        >  1901  
                                                                                        >  1902  extern(Windows) export HBITMAP CreateMappedBitmap(HINSTANCE hInstance, INT_PTR i
                                                                                        >  1903    UINT wFlags, LPCOLORMAP lpColorMap,
                                                                                        >  1904    int iNumMaps);
                                                                                        >  1905  
                                                                                        >  1906  enum : uint { CMB_MASKED = 0x02 }
                                                                                        >  1907  enum : uint { TBSTATE_CHECKED = 0x01 }
                                                                                        >  1908  enum : uint { TBSTATE_PRESSED = 0x02 }
                                                                                        >  1909  enum : uint { TBSTATE_ENABLED = 0x04 }
                                                                                        >  1910  enum : uint { TBSTATE_HIDDEN = 0x08 }
                                                                                        >  1911  enum : uint { TBSTATE_INDETERMINATE = 0x10 }
                                                                                        >  1912  enum : uint { TBSTATE_WRAP = 0x20 }
                                                                                        >  1913  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1914  enum : uint { TBSTATE_ELLIPSES = 0x40 }
                                                                                        >  1915  // #endif
                                                                                        >  1916  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1917  enum : uint { TBSTATE_MARKED = 0x80 }
                                                                                        >  1918  // #endif
                                                                                        >  1919  
                                                                                        >  1920  enum : uint { TBSTYLE_BUTTON = 0x0000 }
                                                                                        >  1921  enum : uint { TBSTYLE_SEP = 0x0001 }
                                                                                        >  1922  enum : uint { TBSTYLE_CHECK = 0x0002 }
                                                                                        >  1923  enum : uint { TBSTYLE_GROUP = 0x0004 }
                                                                                        >  1924  enum : uint { TBSTYLE_CHECKGROUP = TBSTYLE_GROUP | TBSTYLE_CHECK }
                                                                                        >  1925  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1926  enum : uint { TBSTYLE_DROPDOWN = 0x0008 }
                                                                                        >  1927  // #endif
                                                                                        >  1928  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1929  enum : uint { TBSTYLE_AUTOSIZE = 0x0010 }
                                                                                        >  1930  enum : uint { TBSTYLE_NOPREFIX = 0x0020 }
                                                                                        >  1931  // #endif
                                                                                        >  1932  
                                                                                        >  1933  enum : uint { TBSTYLE_TOOLTIPS = 0x0100 }
                                                                                        >  1934  enum : uint { TBSTYLE_WRAPABLE = 0x0200 }
                                                                                        >  1935  enum : uint { TBSTYLE_ALTDRAG = 0x0400 }
                                                                                        >  1936  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  1937  enum : uint { TBSTYLE_FLAT = 0x0800 }
                                                                                        >  1938  enum : uint { TBSTYLE_LIST = 0x1000 }
                                                                                        >  1939  enum : uint { TBSTYLE_CUSTOMERASE = 0x2000 }
                                                                                        >  1940  // #endif
                                                                                        >  1941  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1942  enum : uint { TBSTYLE_REGISTERDROP = 0x4000 }
                                                                                        >  1943  enum : uint { TBSTYLE_TRANSPARENT = 0x8000 }
                                                                                        >  1944  enum : uint { TBSTYLE_EX_DRAWDDARROWS = 0x00000001 }
                                                                                        >  1945  // #endif
                                                                                        >  1946  
                                                                                        >  1947  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  1948  alias TBSTYLE_BUTTON BTNS_BUTTON;
                                                                                        >  1949  alias TBSTYLE_SEP BTNS_SEP;
                                                                                        >  1950  alias TBSTYLE_CHECK BTNS_CHECK;
                                                                                        >  1951  alias TBSTYLE_GROUP BTNS_GROUP;
                                                                                        >  1952  alias TBSTYLE_CHECKGROUP BTNS_CHECKGROUP;
                                                                                        >  1953  alias TBSTYLE_DROPDOWN BTNS_DROPDOWN;
                                                                                        >  1954  alias TBSTYLE_AUTOSIZE BTNS_AUTOSIZE;
                                                                                        >  1955  alias TBSTYLE_NOPREFIX BTNS_NOPREFIX;
                                                                                        >  1956  // #if (_WIN32_IE >= 0x0501)
                                                                                        >  1957  enum : uint { BTNS_SHOWTEXT = 0x0040 }
                                                                                        >  1958  // #endif  // 0x0501
                                                                                        >  1959  enum : uint { BTNS_WHOLEDROPDOWN = 0x0080 }
                                                                                        >  1960  // #endif
                                                                                        >  1961  
                                                                                        >  1962  // #if (_WIN32_IE >= 0x0501)
                                                                                        >  1963  enum : uint { TBSTYLE_EX_MIXEDBUTTONS = 0x00000008 }
                                                                                        >  1964  enum : uint { TBSTYLE_EX_HIDECLIPPEDBUTTONS = 0x00000010 }
                                                                                        >  1965  // #endif  // 0x0501
                                                                                        >  1966  
                                                                                        >  1967  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1968  enum : uint { TBSTYLE_EX_DOUBLEBUFFER = 0x00000080 }
                                                                                        >  1969  // #endif
                                                                                        >  1970  
                                                                                        >  1971  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  1972  
                                                                                        >  1973  struct _NMTBCUSTOMDRAW {
                                                                                        >  1974    NMCUSTOMDRAW nmcd;
                                                                                        >  1975    HBRUSH hbrMonoDither;
                                                                                        >  1976    HBRUSH hbrLines;
                                                                                        >  1977    HPEN hpenLines;
                                                                                        >  1978  
                                                                                        >  1979    COLORREF clrText;
                                                                                        >  1980    COLORREF clrMark;
                                                                                        >  1981    COLORREF clrTextHighlight;
                                                                                        >  1982    COLORREF clrBtnFace;
                                                                                        >  1983    COLORREF clrBtnHighlight;
                                                                                        >  1984    COLORREF clrHighlightHotTrack;
                                                                                        >  1985  
                                                                                        >  1986    RECT rcText;
                                                                                        >  1987  
                                                                                        >  1988    int nStringBkMode;
                                                                                        >  1989    int nHLStringBkMode;
                                                                                        >  1990  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  1991    int iListGap;
                                                                                        >  1992  // #endif
                                                                                        >  1993  }
                                                                                        >  1994  alias _NMTBCUSTOMDRAW NMTBCUSTOMDRAW;
                                                                                        >  1995  alias _NMTBCUSTOMDRAW* LPNMTBCUSTOMDRAW;
                                                                                        >  1996  
                                                                                        >  1997  enum : uint { TBCDRF_NOEDGES = 0x00010000 }
                                                                                        >  1998  enum : uint { TBCDRF_HILITEHOTTRACK = 0x00020000 }
                                                                                        >  1999  enum : uint { TBCDRF_NOOFFSET = 0x00040000 }
                                                                                        >  2000  enum : uint { TBCDRF_NOMARK = 0x00080000 }
                                                                                        >  2001  enum : uint { TBCDRF_NOETCHEDEFFECT = 0x00100000 }
                                                                                        >  2002  // #endif
                                                                                        >  2003  
                                                                                        >  2004  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2005  enum : uint { TBCDRF_BLENDICON = 0x00200000 }
                                                                                        >  2006  enum : uint { TBCDRF_NOBACKGROUND = 0x00400000 }
                                                                                        >  2007  // #endif
                                                                                        >  2008  
                                                                                        >  2009  enum : uint { TB_ENABLEBUTTON = WM_USER + 1 }
                                                                                        >  2010  enum : uint { TB_CHECKBUTTON = WM_USER + 2 }
                                                                                        >  2011  enum : uint { TB_PRESSBUTTON = WM_USER + 3 }
                                                                                        >  2012  enum : uint { TB_HIDEBUTTON = WM_USER + 4 }
                                                                                        >  2013  enum : uint { TB_INDETERMINATE = WM_USER + 5 }
                                                                                        >  2014  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2015  enum : uint { TB_MARKBUTTON = WM_USER + 6 }
                                                                                        >  2016  // #endif
                                                                                        >  2017  enum : uint { TB_ISBUTTONENABLED = WM_USER + 9 }
                                                                                        >  2018  enum : uint { TB_ISBUTTONCHECKED = WM_USER + 10 }
                                                                                        >  2019  enum : uint { TB_ISBUTTONPRESSED = WM_USER + 11 }
                                                                                        >  2020  enum : uint { TB_ISBUTTONHIDDEN = WM_USER + 12 }
                                                                                        >  2021  enum : uint { TB_ISBUTTONINDETERMINATE = WM_USER + 13 }
                                                                                        >  2022  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2023  enum : uint { TB_ISBUTTONHIGHLIGHTED = WM_USER + 14 }
                                                                                        >  2024  // #endif
                                                                                        >  2025  enum : uint { TB_SETSTATE = WM_USER + 17 }
                                                                                        >  2026  enum : uint { TB_GETSTATE = WM_USER + 18 }
                                                                                        >  2027  enum : uint { TB_ADDBITMAP = WM_USER + 19 }
                                                                                        >  2028  
                                                                                        >  2029  // #ifdef _WIN32
                                                                                        >  2030  struct tagTBADDBITMAP {
                                                                                        >  2031    HINSTANCE hInst;
                                                                                        >  2032    UINT_PTR nID;
                                                                                        >  2033  }
                                                                                        >  2034  alias tagTBADDBITMAP TBADDBITMAP;
                                                                                        >  2035  alias tagTBADDBITMAP* LPTBADDBITMAP;
                                                                                        >  2036  
                                                                                        >  2037  HINSTANCE HINST_COMMCTRL = cast(HINSTANCE)(-1);
                                                                                        >  2038  enum : uint { IDB_STD_SMALL_COLOR = 0 }
                                                                                        >  2039  enum : uint { IDB_STD_LARGE_COLOR = 1 }
                                                                                        >  2040  enum : uint { IDB_VIEW_SMALL_COLOR = 4 }
                                                                                        >  2041  enum : uint { IDB_VIEW_LARGE_COLOR = 5 }
                                                                                        >  2042  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2043  enum : uint { IDB_HIST_SMALL_COLOR = 8 }
                                                                                        >  2044  enum : uint { IDB_HIST_LARGE_COLOR = 9 }
                                                                                        >  2045  // #endif
                                                                                        >  2046  
                                                                                        >  2047  enum : uint { STD_CUT = 0 }
                                                                                        >  2048  enum : uint { STD_COPY = 1 }
                                                                                        >  2049  enum : uint { STD_PASTE = 2 }
                                                                                        >  2050  enum : uint { STD_UNDO = 3 }
                                                                                        >  2051  enum : uint { STD_REDOW = 4 }
                                                                                        >  2052  enum : uint { STD_DELETE = 5 }
                                                                                        >  2053  enum : uint { STD_FILENEW = 6 }
                                                                                        >  2054  enum : uint { STD_FILEOPEN = 7 }
                                                                                        >  2055  enum : uint { STD_FILESAVE = 8 }
                                                                                        >  2056  enum : uint { STD_PRINTPRE = 9 }
                                                                                        >  2057  enum : uint { STD_PROPERTIES = 10 }
                                                                                        >  2058  enum : uint { STD_HELP = 11 }
                                                                                        >  2059  enum : uint { STD_FIND = 12 }
                                                                                        >  2060  enum : uint { STD_REPLACE = 13 }
                                                                                        >  2061  enum : uint { STD_PRINT = 14 }
                                                                                        >  2062  
                                                                                        >  2063  enum : uint { VIEW_LARGEICONS = 0 }
                                                                                        >  2064  enum : uint { VIEW_SMALLICONS = 1 }
                                                                                        >  2065  enum : uint { VIEW_LIST = 2 }
                                                                                        >  2066  enum : uint { VIEW_DETAILS = 3 }
                                                                                        >  2067  enum : uint { VIEW_SORTNAME = 4 }
                                                                                        >  2068  enum : uint { VIEW_SORTSIZE = 5 }
                                                                                        >  2069  enum : uint { VIEW_SORTDATE = 6 }
                                                                                        >  2070  enum : uint { VIEW_SORTTYPE = 7 }
                                                                                        >  2071  enum : uint { VIEW_PARENTFOLDER = 8 }
                                                                                        >  2072  enum : uint { VIEW_NETCONNECT = 9 }
                                                                                        >  2073  enum : uint { VIEW_NETDISCONNECT = 10 }
                                                                                        >  2074  enum : uint { VIEW_NEWFOLDER = 11 }
                                                                                        >  2075  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2076  enum : uint { VIEW_VIEWMENU = 12 }
                                                                                        >  2077  // #endif
                                                                                        >  2078  
                                                                                        >  2079  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2080  enum : uint { HIST_BACK = 0 }
                                                                                        >  2081  enum : uint { HIST_FORWARD = 1 }
                                                                                        >  2082  enum : uint { HIST_FAVORITES = 2 }
                                                                                        >  2083  enum : uint { HIST_ADDTOFAVORITES = 3 }
                                                                                        >  2084  enum : uint { HIST_VIEWTREE = 4 }
                                                                                        >  2085  // #endif
                                                                                        >  2086  
                                                                                        >  2087  // #endif
                                                                                        >  2088  
                                                                                        >  2089  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2090  enum : uint { TB_ADDBUTTONSA = WM_USER + 20 }
                                                                                        >  2091  enum : uint { TB_INSERTBUTTONA = WM_USER + 21 }
                                                                                        >  2092  // #else
                                                                                        >  2093  // #...
                                                                                        >  2094  // #...
                                                                                        >  2095  // #endif
                                                                                        >  2096  
                                                                                        >  2097  enum : uint { TB_DELETEBUTTON = WM_USER + 22 }
                                                                                        >  2098  enum : uint { TB_GETBUTTON = WM_USER + 23 }
                                                                                        >  2099  enum : uint { TB_BUTTONCOUNT = WM_USER + 24 }
                                                                                        >  2100  enum : uint { TB_COMMANDTOINDEX = WM_USER + 25 }
                                                                                        >  2101  
                                                                                        >  2102  // #ifdef _WIN32
                                                                                        >  2103  
                                                                                        >  2104  struct tagTBSAVEPARAMSA {
                                                                                        >  2105    HKEY hkr;
                                                                                        >  2106    LPCSTR pszSubKey;
                                                                                        >  2107    LPCSTR pszValueName;
                                                                                        >  2108  }
                                                                                        >  2109  alias tagTBSAVEPARAMSA TBSAVEPARAMSA;
                                                                                        >  2110  alias tagTBSAVEPARAMSA* LPTBSAVEPARAMSA;
                                                                                        >  2111  
                                                                                        >  2112  struct tagTBSAVEPARAMSW {
                                                                                        >  2113    HKEY hkr;
                                                                                        >  2114    LPCWSTR pszSubKey;
                                                                                        >  2115    LPCWSTR pszValueName;
                                                                                        >  2116  }
                                                                                        >  2117  alias tagTBSAVEPARAMSW TBSAVEPARAMSW;
                                                                                        >  2118  alias tagTBSAVEPARAMSW* LPTBSAVEPARAMW;
                                                                                        >  2119  
                                                                                        >  2120  // #ifdef UNICODE
                                                                                        >  2121  // #...
                                                                                        >  2122  // #...
                                                                                        >  2123  // #else
                                                                                        >  2124  alias TBSAVEPARAMSA TBSAVEPARAMS;
                                                                                        >  2125  alias LPTBSAVEPARAMSA LPTBSAVEPARAMS;
                                                                                        >  2126  // #endif
                                                                                        >  2127  
                                                                                        >  2128  // #endif  // _WIN32
                                                                                        >  2129  
                                                                                        >  2130  enum : uint { TB_SAVERESTOREA = WM_USER + 26 }
                                                                                        >  2131  enum : uint { TB_SAVERESTOREW = WM_USER + 76 }
                                                                                        >  2132  enum : uint { TB_CUSTOMIZE = WM_USER + 27 }
                                                                                        >  2133  enum : uint { TB_ADDSTRINGA = WM_USER + 28 }
                                                                                        >  2134  enum : uint { TB_ADDSTRINGW = WM_USER + 77 }
                                                                                        >  2135  enum : uint { TB_GETITEMRECT = WM_USER + 29 }
                                                                                        >  2136  enum : uint { TB_BUTTONSTRUCTSIZE = WM_USER + 30 }
                                                                                        >  2137  enum : uint { TB_SETBUTTONSIZE = WM_USER + 31 }
                                                                                        >  2138  enum : uint { TB_SETBITMAPSIZE = WM_USER + 32 }
                                                                                        >  2139  enum : uint { TB_AUTOSIZE = WM_USER + 33 }
                                                                                        >  2140  enum : uint { TB_GETTOOLTIPS = WM_USER + 35 }
                                                                                        >  2141  enum : uint { TB_SETTOOLTIPS = WM_USER + 36 }
                                                                                        >  2142  enum : uint { TB_SETPARENT = WM_USER + 37 }
                                                                                        >  2143  enum : uint { TB_SETROWS = WM_USER + 39 }
                                                                                        >  2144  enum : uint { TB_GETROWS = WM_USER + 40 }
                                                                                        >  2145  enum : uint { TB_SETCMDID = WM_USER + 42 }
                                                                                        >  2146  enum : uint { TB_CHANGEBITMAP = WM_USER + 43 }
                                                                                        >  2147  enum : uint { TB_GETBITMAP = WM_USER + 44 }
                                                                                        >  2148  enum : uint { TB_GETBUTTONTEXTA = WM_USER + 45 }
                                                                                        >  2149  enum : uint { TB_GETBUTTONTEXTW = WM_USER + 75 }
                                                                                        >  2150  enum : uint { TB_REPLACEBITMAP = WM_USER + 46 }
                                                                                        >  2151  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2152  enum : uint { TB_SETINDENT = WM_USER + 47 }
                                                                                        >  2153  enum : uint { TB_SETIMAGELIST = WM_USER + 48 }
                                                                                        >  2154  enum : uint { TB_GETIMAGELIST = WM_USER + 49 }
                                                                                        >  2155  enum : uint { TB_LOADIMAGES = WM_USER + 50 }
                                                                                        >  2156  enum : uint { TB_GETRECT = WM_USER + 51 }
                                                                                        >  2157  enum : uint { TB_SETHOTIMAGELIST = WM_USER + 52 }
                                                                                        >  2158  enum : uint { TB_GETHOTIMAGELIST = WM_USER + 53 }
                                                                                        >  2159  enum : uint { TB_SETDISABLEDIMAGELIST = WM_USER + 54 }
                                                                                        >  2160  enum : uint { TB_GETDISABLEDIMAGELIST = WM_USER + 55 }
                                                                                        >  2161  enum : uint { TB_SETSTYLE = WM_USER + 56 }
                                                                                        >  2162  enum : uint { TB_GETSTYLE = WM_USER + 57 }
                                                                                        >  2163  enum : uint { TB_GETBUTTONSIZE = WM_USER + 58 }
                                                                                        >  2164  enum : uint { TB_SETBUTTONWIDTH = WM_USER + 59 }
                                                                                        >  2165  enum : uint { TB_SETMAXTEXTROWS = WM_USER + 60 }
                                                                                        >  2166  enum : uint { TB_GETTEXTROWS = WM_USER + 61 }
                                                                                        >  2167  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  2168  
                                                                                        >  2169  // #ifdef UNICODE
                                                                                        >  2170  // #...
                                                                                        >  2171  // #...
                                                                                        >  2172  // #...
                                                                                        >  2173  // #else
                                                                                        >  2174  alias TB_GETBUTTONTEXTA TB_GETBUTTONTEXT;
                                                                                        >  2175  alias TB_SAVERESTOREA TB_SAVERESTORE;
                                                                                        >  2176  alias TB_ADDSTRINGA TB_ADDSTRING;
                                                                                        >  2177  // #endif
                                                                                        >  2178  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2179  enum : uint { TB_GETOBJECT = WM_USER + 62 }
                                                                                        >  2180  enum : uint { TB_GETHOTITEM = WM_USER + 71 }
                                                                                        >  2181  enum : uint { TB_SETHOTITEM = WM_USER + 72 }
                                                                                        >  2182  enum : uint { TB_SETANCHORHIGHLIGHT = WM_USER + 73 }
                                                                                        >  2183  enum : uint { TB_GETANCHORHIGHLIGHT = WM_USER + 74 }
                                                                                        >  2184  enum : uint { TB_MAPACCELERATORA = WM_USER + 78 }
                                                                                        >  2185  
                                                                                        >  2186  struct _0 {
                                                                                        >  2187    int iButton;
                                                                                        >  2188    DWORD dwFlags;
                                                                                        >  2189  }
                                                                                        >  2190  alias _0 TBINSERTMARK;
                                                                                        >  2191  alias _0* LPTBINSERTMARK;
                                                                                        >  2192  
                                                                                        >  2193  enum : uint { TBIMHT_AFTER = 0x00000001 }
                                                                                        >  2194  enum : uint { TBIMHT_BACKGROUND = 0x00000002 }
                                                                                        >  2195  
                                                                                        >  2196  enum : uint { TB_GETINSERTMARK = WM_USER + 79 }
                                                                                        >  2197  enum : uint { TB_SETINSERTMARK = WM_USER + 80 }
                                                                                        >  2198  enum : uint { TB_INSERTMARKHITTEST = WM_USER + 81 }
                                                                                        >  2199  enum : uint { TB_MOVEBUTTON = WM_USER + 82 }
                                                                                        >  2200  enum : uint { TB_GETMAXSIZE = WM_USER + 83 }
                                                                                        >  2201  enum : uint { TB_SETEXTENDEDSTYLE = WM_USER + 84 }
                                                                                        >  2202  enum : uint { TB_GETEXTENDEDSTYLE = WM_USER + 85 }
                                                                                        >  2203  enum : uint { TB_GETPADDING = WM_USER + 86 }
                                                                                        >  2204  enum : uint { TB_SETPADDING = WM_USER + 87 }
                                                                                        >  2205  enum : uint { TB_SETINSERTMARKCOLOR = WM_USER + 88 }
                                                                                        >  2206  enum : uint { TB_GETINSERTMARKCOLOR = WM_USER + 89 }
                                                                                        >  2207  
                                                                                        >  2208  alias CCM_SETCOLORSCHEME TB_SETCOLORSCHEME;
                                                                                        >  2209  alias CCM_GETCOLORSCHEME TB_GETCOLORSCHEME;
                                                                                        >  2210  
                                                                                        >  2211  alias CCM_SETUNICODEFORMAT TB_SETUNICODEFORMAT;
                                                                                        >  2212  alias CCM_GETUNICODEFORMAT TB_GETUNICODEFORMAT;
                                                                                        >  2213  
                                                                                        >  2214  enum : uint { TB_MAPACCELERATORW = WM_USER + 90 }
                                                                                        >  2215  // #ifdef UNICODE
                                                                                        >  2216  // #...
                                                                                        >  2217  // #else
                                                                                        >  2218  alias TB_MAPACCELERATORA TB_MAPACCELERATOR;
                                                                                        >  2219  // #endif
                                                                                        >  2220  
                                                                                        >  2221  // #endif  // _WIN32_IE >= 0x0400
                                                                                        >  2222  
                                                                                        >  2223  struct _1 {
                                                                                        >  2224    HINSTANCE hInstOld;
                                                                                        >  2225    UINT_PTR nIDOld;
                                                                                        >  2226    HINSTANCE hInstNew;
                                                                                        >  2227    UINT_PTR nIDNew;
                                                                                        >  2228    int nButtons;
                                                                                        >  2229  }
                                                                                        >  2230  alias _1 TBREPLACEBITMAP;
                                                                                        >  2231  alias _1* LPTBREPLACEBITMAP;
                                                                                        >  2232  
                                                                                        >  2233  // #ifdef _WIN32
                                                                                        >  2234  
                                                                                        >  2235  enum : uint { TBBF_LARGE = 0x0001 }
                                                                                        >  2236  
                                                                                        >  2237  enum : uint { TB_GETBITMAPFLAGS = WM_USER + 41 }
                                                                                        >  2238  
                                                                                        >  2239  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2240  enum : uint { TBIF_IMAGE = 0x00000001 }
                                                                                        >  2241  enum : uint { TBIF_TEXT = 0x00000002 }
                                                                                        >  2242  enum : uint { TBIF_STATE = 0x00000004 }
                                                                                        >  2243  enum : uint { TBIF_STYLE = 0x00000008 }
                                                                                        >  2244  enum : uint { TBIF_LPARAM = 0x00000010 }
                                                                                        >  2245  enum : uint { TBIF_COMMAND = 0x00000020 }
                                                                                        >  2246  enum : uint { TBIF_SIZE = 0x00000040 }
                                                                                        >  2247  
                                                                                        >  2248  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2249  enum : uint { TBIF_BYINDEX = 0x80000000 }
                                                                                        >  2250  // #endif
                                                                                        >  2251  
                                                                                        >  2252  struct _2 {
                                                                                        >  2253    UINT cbSize;
                                                                                        >  2254    DWORD dwMask;
                                                                                        >  2255    int idCommand;
                                                                                        >  2256    int iImage;
                                                                                        >  2257    BYTE fsState;
                                                                                        >  2258    BYTE fsStyle;
                                                                                        >  2259    WORD cx;
                                                                                        >  2260    DWORD_PTR lParam;
                                                                                        >  2261    LPSTR pszText;
                                                                                        >  2262    int cchText;
                                                                                        >  2263  }
                                                                                        >  2264  alias _2 TBBUTTONINFOA;
                                                                                        >  2265  alias _2* LPTBBUTTONINFOA;
                                                                                        >  2266  
                                                                                        >  2267  struct _3 {
                                                                                        >  2268    UINT cbSize;
                                                                                        >  2269    DWORD dwMask;
                                                                                        >  2270    int idCommand;
                                                                                        >  2271    int iImage;
                                                                                        >  2272    BYTE fsState;
                                                                                        >  2273    BYTE fsStyle;
                                                                                        >  2274    WORD cx;
                                                                                        >  2275    DWORD_PTR lParam;
                                                                                        >  2276    LPWSTR pszText;
                                                                                        >  2277    int cchText;
                                                                                        >  2278  }
                                                                                        >  2279  alias _3 TBBUTTONINFOW;
                                                                                        >  2280  alias _3* LPTBBUTTONINFOW;
                                                                                        >  2281  
                                                                                        >  2282  // #ifdef UNICODE
                                                                                        >  2283  // #...
                                                                                        >  2284  // #...
                                                                                        >  2285  // #else
                                                                                        >  2286  alias TBBUTTONINFOA TBBUTTONINFO;
                                                                                        >  2287  alias LPTBBUTTONINFOA LPTBBUTTONINFO;
                                                                                        >  2288  // #endif
                                                                                        >  2289  
                                                                                        >  2290  enum : uint { TB_GETBUTTONINFOW = WM_USER + 63 }
                                                                                        >  2291  enum : uint { TB_SETBUTTONINFOW = WM_USER + 64 }
                                                                                        >  2292  enum : uint { TB_GETBUTTONINFOA = WM_USER + 65 }
                                                                                        >  2293  enum : uint { TB_SETBUTTONINFOA = WM_USER + 66 }
                                                                                        >  2294  // #ifdef UNICODE
                                                                                        >  2295  // #...
                                                                                        >  2296  // #...
                                                                                        >  2297  // #else
                                                                                        >  2298  alias TB_GETBUTTONINFOA TB_GETBUTTONINFO;
                                                                                        >  2299  alias TB_SETBUTTONINFOA TB_SETBUTTONINFO;
                                                                                        >  2300  // #endif
                                                                                        >  2301  
                                                                                        >  2302  enum : uint { TB_INSERTBUTTONW = WM_USER + 67 }
                                                                                        >  2303  enum : uint { TB_ADDBUTTONSW = WM_USER + 68 }
                                                                                        >  2304  
                                                                                        >  2305  enum : uint { TB_HITTEST = WM_USER + 69 }
                                                                                        >  2306  
                                                                                        >  2307  // #ifdef UNICODE
                                                                                        >  2308  // #...
                                                                                        >  2309  // #...
                                                                                        >  2310  // #else
                                                                                        >  2311  alias TB_INSERTBUTTONA TB_INSERTBUTTON;
                                                                                        >  2312  alias TB_ADDBUTTONSA TB_ADDBUTTONS;
                                                                                        >  2313  // #endif
                                                                                        >  2314  
                                                                                        >  2315  enum : uint { TB_SETDRAWTEXTFLAGS = WM_USER + 70 }
                                                                                        >  2316  
                                                                                        >  2317  // #endif  // _WIN32_IE >= 0x0400
                                                                                        >  2318  
                                                                                        >  2319  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2320  
                                                                                        >  2321  enum : uint { TB_GETSTRINGW = WM_USER + 91 }
                                                                                        >  2322  enum : uint { TB_GETSTRINGA = WM_USER + 92 }
                                                                                        >  2323  // #ifdef UNICODE
                                                                                        >  2324  // #...
                                                                                        >  2325  // #else
                                                                                        >  2326  alias TB_GETSTRINGA TB_GETSTRING;
                                                                                        >  2327  // #endif
                                                                                        >  2328  
                                                                                        >  2329  // #endif  // _WIN32_IE >= 0x0500
                                                                                        >  2330  
                                                                                        >  2331  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  2332  enum : uint { TBMF_PAD = 0x00000001 }
                                                                                        >  2333  enum : uint { TBMF_BARPAD = 0x00000002 }
                                                                                        >  2334  enum : uint { TBMF_BUTTONSPACING = 0x00000004 }
                                                                                        >  2335  
                                                                                        >  2336  struct _4 {
                                                                                        >  2337    UINT cbSize;
                                                                                        >  2338    DWORD dwMask;
                                                                                        >  2339    int cxPad;
                                                                                        >  2340    int cyPad;
                                                                                        >  2341    int cxBarPad;
                                                                                        >  2342    int cyBarPad;
                                                                                        >  2343    int cxButtonSpacing;
                                                                                        >  2344    int cyButtonSpacing;
                                                                                        >  2345  }
                                                                                        >  2346  alias _4 TBMETRICS;
                                                                                        >  2347  alias _4* LPTBMETRICS;
                                                                                        >  2348  
                                                                                        >  2349  enum : uint { TB_GETMETRICS = WM_USER + 101 }
                                                                                        >  2350  enum : uint { TB_SETMETRICS = WM_USER + 102 }
                                                                                        >  2351  // #endif
                                                                                        >  2352  
                                                                                        >  2353  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  2354  alias CCM_SETWINDOWTHEME TB_SETWINDOWTHEME;
                                                                                        >  2355  // #endif
                                                                                        >  2356  
                                                                                        >  2357  enum : uint { TBN_GETBUTTONINFOA = TBN_FIRST-0 }
                                                                                        >  2358  enum : uint { TBN_BEGINDRAG = TBN_FIRST-1 }
                                                                                        >  2359  enum : uint { TBN_ENDDRAG = TBN_FIRST-2 }
                                                                                        >  2360  enum : uint { TBN_BEGINADJUST = TBN_FIRST-3 }
                                                                                        >  2361  enum : uint { TBN_ENDADJUST = TBN_FIRST-4 }
                                                                                        >  2362  enum : uint { TBN_RESET = TBN_FIRST-5 }
                                                                                        >  2363  enum : uint { TBN_QUERYINSERT = TBN_FIRST-6 }
                                                                                        >  2364  enum : uint { TBN_QUERYDELETE = TBN_FIRST-7 }
                                                                                        >  2365  enum : uint { TBN_TOOLBARCHANGE = TBN_FIRST-8 }
                                                                                        >  2366  enum : uint { TBN_CUSTHELP = TBN_FIRST-9 }
                                                                                        >  2367  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2368  enum : uint { TBN_DROPDOWN = TBN_FIRST - 10 }
                                                                                        >  2369  // #endif
                                                                                        >  2370  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2371  enum : uint { TBN_GETOBJECT = TBN_FIRST - 12 }
                                                                                        >  2372  
                                                                                        >  2373  struct tagNMTBHOTITEM {
                                                                                        >  2374    NMHDR hdr;
                                                                                        >  2375    int idOld;
                                                                                        >  2376    int idNew;
                                                                                        >  2377    DWORD dwFlags;
                                                                                        >  2378  }
                                                                                        >  2379  alias tagNMTBHOTITEM NMTBHOTITEM;
                                                                                        >  2380  alias tagNMTBHOTITEM* LPNMTBHOTITEM;
                                                                                        >  2381  
                                                                                        >  2382  enum : uint { HICF_OTHER = 0x00000000 }
                                                                                        >  2383  enum : uint { HICF_MOUSE = 0x00000001 }
                                                                                        >  2384  enum : uint { HICF_ARROWKEYS = 0x00000002 }
                                                                                        >  2385  enum : uint { HICF_ACCELERATOR = 0x00000004 }
                                                                                        >  2386  enum : uint { HICF_DUPACCEL = 0x00000008 }
                                                                                        >  2387  enum : uint { HICF_ENTERING = 0x00000010 }
                                                                                        >  2388  enum : uint { HICF_LEAVING = 0x00000020 }
                                                                                        >  2389  enum : uint { HICF_RESELECT = 0x00000040 }
                                                                                        >  2390  enum : uint { HICF_LMOUSE = 0x00000080 }
                                                                                        >  2391  enum : uint { HICF_TOGGLEDROPDOWN = 0x00000100 }
                                                                                        >  2392  
                                                                                        >  2393  enum : uint { TBN_HOTITEMCHANGE = TBN_FIRST - 13 }
                                                                                        >  2394  enum : uint { TBN_DRAGOUT = TBN_FIRST - 14 }
                                                                                        >  2395  enum : uint { TBN_DELETINGBUTTON = TBN_FIRST - 15 }
                                                                                        >  2396  enum : uint { TBN_GETDISPINFOA = TBN_FIRST - 16 }
                                                                                        >  2397  enum : uint { TBN_GETDISPINFOW = TBN_FIRST - 17 }
                                                                                        >  2398  enum : uint { TBN_GETINFOTIPA = TBN_FIRST - 18 }
                                                                                        >  2399  enum : uint { TBN_GETINFOTIPW = TBN_FIRST - 19 }
                                                                                        >  2400  enum : uint { TBN_GETBUTTONINFOW = TBN_FIRST - 20 }
                                                                                        >  2401  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2402  enum : uint { TBN_RESTORE = TBN_FIRST - 21 }
                                                                                        >  2403  enum : uint { TBN_SAVE = TBN_FIRST - 22 }
                                                                                        >  2404  enum : uint { TBN_INITCUSTOMIZE = TBN_FIRST - 23 }
                                                                                        >  2405  enum : uint { TBNRF_HIDEHELP = 0x00000001 }
                                                                                        >  2406  enum : uint { TBNRF_ENDCUSTOMIZE = 0x00000002 }
                                                                                        >  2407  // #endif // (_WIN32_IE >= 0x0500)
                                                                                        >  2408  
                                                                                        >  2409  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2410  
                                                                                        >  2411  struct tagNMTBSAVE {
                                                                                        >  2412    NMHDR hdr;
                                                                                        >  2413    DWORD * pData;
                                                                                        >  2414    DWORD * pCurrent;
                                                                                        >  2415    UINT cbData;
                                                                                        >  2416    int iItem;
                                                                                        >  2417    int cButtons;
                                                                                        >  2418    TBBUTTON tbButton;
                                                                                        >  2419  }
                                                                                        >  2420  alias tagNMTBSAVE NMTBSAVE;
                                                                                        >  2421  alias tagNMTBSAVE* LPNMTBSAVE;
                                                                                        >  2422  
                                                                                        >  2423  struct tagNMTBRESTORE {
                                                                                        >  2424    NMHDR hdr;
                                                                                        >  2425    DWORD * pData;
                                                                                        >  2426    DWORD * pCurrent;
                                                                                        >  2427    UINT cbData;
                                                                                        >  2428    int iItem;
                                                                                        >  2429    int cButtons;
                                                                                        >  2430    int cbBytesPerRecord;
                                                                                        >  2431    TBBUTTON tbButton;
                                                                                        >  2432  }
                                                                                        >  2433  alias tagNMTBRESTORE NMTBRESTORE;
                                                                                        >  2434  alias tagNMTBRESTORE* LPNMTBRESTORE;
                                                                                        >  2435  
                                                                                        >  2436  // #endif // (_WIN32_IE >= 0x0500)
                                                                                        >  2437  
                                                                                        >  2438  struct tagNMTBGETINFOTIPA {
                                                                                        >  2439    NMHDR hdr;
                                                                                        >  2440    LPSTR pszText;
                                                                                        >  2441    int cchTextMax;
                                                                                        >  2442    int iItem;
                                                                                        >  2443    LPARAM lParam;
                                                                                        >  2444  }
                                                                                        >  2445  alias tagNMTBGETINFOTIPA NMTBGETINFOTIPA;
                                                                                        >  2446  alias tagNMTBGETINFOTIPA* LPNMTBGETINFOTIPA;
                                                                                        >  2447  
                                                                                        >  2448  struct tagNMTBGETINFOTIPW {
                                                                                        >  2449    NMHDR hdr;
                                                                                        >  2450    LPWSTR pszText;
                                                                                        >  2451    int cchTextMax;
                                                                                        >  2452    int iItem;
                                                                                        >  2453    LPARAM lParam;
                                                                                        >  2454  }
                                                                                        >  2455  alias tagNMTBGETINFOTIPW NMTBGETINFOTIPW;
                                                                                        >  2456  alias tagNMTBGETINFOTIPW* LPNMTBGETINFOTIPW;
                                                                                        >  2457  
                                                                                        >  2458  // #ifdef UNICODE
                                                                                        >  2459  // #...
                                                                                        >  2460  // #...
                                                                                        >  2461  // #...
                                                                                        >  2462  // #else
                                                                                        >  2463  alias TBN_GETINFOTIPA TBN_GETINFOTIP;
                                                                                        >  2464  alias NMTBGETINFOTIPA NMTBGETINFOTIP;
                                                                                        >  2465  alias LPNMTBGETINFOTIPA LPNMTBGETINFOTIP;
                                                                                        >  2466  // #endif
                                                                                        >  2467  
                                                                                        >  2468  enum : uint { TBNF_IMAGE = 0x00000001 }
                                                                                        >  2469  enum : uint { TBNF_TEXT = 0x00000002 }
                                                                                        >  2470  enum : uint { TBNF_DI_SETITEM = 0x10000000 }
                                                                                        >  2471  
                                                                                        >  2472  struct _5 {
                                                                                        >  2473    NMHDR hdr;
                                                                                        >  2474    DWORD dwMask;
                                                                                        >  2475    int idCommand;
                                                                                        >  2476    DWORD_PTR lParam;
                                                                                        >  2477    int iImage;
                                                                                        >  2478    LPSTR pszText;
                                                                                        >  2479    int cchText;
                                                                                        >  2480  }
                                                                                        >  2481  alias _5 NMTBDISPINFOA;
                                                                                        >  2482  alias _5* LPNMTBDISPINFOA;
                                                                                        >  2483  
                                                                                        >  2484  struct _6 {
                                                                                        >  2485    NMHDR hdr;
                                                                                        >  2486    DWORD dwMask;
                                                                                        >  2487    int idCommand;
                                                                                        >  2488    DWORD_PTR lParam;
                                                                                        >  2489    int iImage;
                                                                                        >  2490    LPWSTR pszText;
                                                                                        >  2491    int cchText;
                                                                                        >  2492  }
                                                                                        >  2493  alias _6 NMTBDISPINFOW;
                                                                                        >  2494  alias _6* LPNMTBDISPINFOW;
                                                                                        >  2495  
                                                                                        >  2496  // #ifdef UNICODE
                                                                                        >  2497  // #...
                                                                                        >  2498  // #...
                                                                                        >  2499  // #...
                                                                                        >  2500  // #else
                                                                                        >  2501  alias TBN_GETDISPINFOA TBN_GETDISPINFO;
                                                                                        >  2502  alias NMTBDISPINFOA NMTBDISPINFO;
                                                                                        >  2503  alias LPNMTBDISPINFOA LPNMTBDISPINFO;
                                                                                        >  2504  // #endif
                                                                                        >  2505  
                                                                                        >  2506  enum : uint { TBDDRET_DEFAULT = 0 }
                                                                                        >  2507  enum : uint { TBDDRET_NODEFAULT = 1 }
                                                                                        >  2508  enum : uint { TBDDRET_TREATPRESSED = 2 }
                                                                                        >  2509  
                                                                                        >  2510  // #endif
                                                                                        >  2511  
                                                                                        >  2512  // #ifdef UNICODE
                                                                                        >  2513  // #...
                                                                                        >  2514  // #else
                                                                                        >  2515  alias TBN_GETBUTTONINFOA TBN_GETBUTTONINFO;
                                                                                        >  2516  // #endif
                                                                                        >  2517  
                                                                                        >  2518  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2519  alias NMTOOLBARA TBNOTIFYA;
                                                                                        >  2520  alias NMTOOLBARW TBNOTIFYW;
                                                                                        >  2521  alias LPNMTOOLBARA LPTBNOTIFYA;
                                                                                        >  2522  alias LPNMTOOLBARW LPTBNOTIFYW;
                                                                                        >  2523  // #else
                                                                                        >  2524  // #...
                                                                                        >  2525  // #...
                                                                                        >  2526  // #...
                                                                                        >  2527  // #...
                                                                                        >  2528  // #...
                                                                                        >  2529  // #...
                                                                                        >  2530  // #endif
                                                                                        >  2531  
                                                                                        >  2532  alias NMTOOLBAR TBNOTIFY;
                                                                                        >  2533  alias LPNMTOOLBAR LPTBNOTIFY;
                                                                                        >  2534  
                                                                                        >  2535  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2536  struct tagNMTOOLBARA {
                                                                                        >  2537    NMHDR hdr;
                                                                                        >  2538    int iItem;
                                                                                        >  2539    TBBUTTON tbButton;
                                                                                        >  2540    int cchText;
                                                                                        >  2541    LPSTR pszText;
                                                                                        >  2542  // #if (_WIN32_IE >= 0x500)
                                                                                        >  2543    RECT rcButton;
                                                                                        >  2544  // #endif
                                                                                        >  2545  }
                                                                                        >  2546  alias tagNMTOOLBARA NMTOOLBARA;
                                                                                        >  2547  alias tagNMTOOLBARA* LPNMTOOLBARA;
                                                                                        >  2548  
                                                                                        >  2549  // #endif
                                                                                        >  2550  
                                                                                        >  2551  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2552  struct tagNMTOOLBARW {
                                                                                        >  2553    NMHDR hdr;
                                                                                        >  2554    int iItem;
                                                                                        >  2555    TBBUTTON tbButton;
                                                                                        >  2556    int cchText;
                                                                                        >  2557    LPWSTR pszText;
                                                                                        >  2558  // #if (_WIN32_IE >= 0x500)
                                                                                        >  2559    RECT rcButton;
                                                                                        >  2560  // #endif
                                                                                        >  2561  }
                                                                                        >  2562  alias tagNMTOOLBARW NMTOOLBARW;
                                                                                        >  2563  alias tagNMTOOLBARW* LPNMTOOLBARW;
                                                                                        >  2564  
                                                                                        >  2565  // #endif
                                                                                        >  2566  
                                                                                        >  2567  // #ifdef UNICODE
                                                                                        >  2568  // #...
                                                                                        >  2569  // #...
                                                                                        >  2570  // #else
                                                                                        >  2571  alias NMTOOLBARA NMTOOLBAR;
                                                                                        >  2572  alias LPNMTOOLBARA LPNMTOOLBAR;
                                                                                        >  2573  // #endif
                                                                                        >  2574  
                                                                                        >  2575  // #endif
                                                                                        >  2576  
                                                                                        >  2577  // #endif      // NOTOOLBAR
                                                                                        >  2578  
                                                                                        >  2579  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2580  
                                                                                        >  2581  // #ifndef NOREBAR
                                                                                        >  2582  
                                                                                        >  2583  // #ifdef _WIN32
                                                                                        >  2584  const wchar[] REBARCLASSNAMEW = "ReBarWindow32";
                                                                                        >  2585  const char[] REBARCLASSNAMEA = "ReBarWindow32";
                                                                                        >  2586  
                                                                                        >  2587  // #ifdef  UNICODE
                                                                                        >  2588  // #...
                                                                                        >  2589  // #else
                                                                                        >  2590  alias REBARCLASSNAMEA REBARCLASSNAME;
                                                                                        >  2591  // #endif
                                                                                        >  2592  
                                                                                        >  2593  // #else
                                                                                        >  2594  // #...
                                                                                        >  2595  // #endif
                                                                                        >  2596  
                                                                                        >  2597  enum : uint { RBIM_IMAGELIST = 0x00000001 }
                                                                                        >  2598  
                                                                                        >  2599  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2600  enum : uint { RBS_TOOLTIPS = 0x0100 }
                                                                                        >  2601  enum : uint { RBS_VARHEIGHT = 0x0200 }
                                                                                        >  2602  enum : uint { RBS_BANDBORDERS = 0x0400 }
                                                                                        >  2603  enum : uint { RBS_FIXEDORDER = 0x0800 }
                                                                                        >  2604  enum : uint { RBS_REGISTERDROP = 0x1000 }
                                                                                        >  2605  enum : uint { RBS_AUTOSIZE = 0x2000 }
                                                                                        >  2606  enum : uint { RBS_VERTICALGRIPPER = 0x4000 }
                                                                                        >  2607  enum : uint { RBS_DBLCLKTOGGLE = 0x8000 }
                                                                                        >  2608  // #else
                                                                                        >  2609  // #...
                                                                                        >  2610  // #...
                                                                                        >  2611  // #...
                                                                                        >  2612  // #...
                                                                                        >  2613  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  2614  
                                                                                        >  2615  struct tagREBARINFO {
                                                                                        >  2616    UINT cbSize;
                                                                                        >  2617    UINT fMask;
                                                                                        >  2618  // #ifndef NOIMAGEAPIS
                                                                                        >  2619    HIMAGELIST himl;
                                                                                        >  2620  // #else
                                                                                        >  2621  // ...
                                                                                        >  2622  // #endif
                                                                                        >  2623  }
                                                                                        >  2624  alias tagREBARINFO REBARINFO;
                                                                                        >  2625  alias tagREBARINFO* LPREBARINFO;
                                                                                        >  2626  
                                                                                        >  2627  enum : uint { RBBS_BREAK = 0x00000001 }
                                                                                        >  2628  enum : uint { RBBS_FIXEDSIZE = 0x00000002 }
                                                                                        >  2629  enum : uint { RBBS_CHILDEDGE = 0x00000004 }
                                                                                        >  2630  enum : uint { RBBS_HIDDEN = 0x00000008 }
                                                                                        >  2631  enum : uint { RBBS_NOVERT = 0x00000010 }
                                                                                        >  2632  enum : uint { RBBS_FIXEDBMP = 0x00000020 }
                                                                                        >  2633  // #if (_WIN32_IE >= 0x0400)               //
                                                                                        >  2634  enum : uint { RBBS_VARIABLEHEIGHT = 0x00000040 }
                                                                                        >  2635  enum : uint { RBBS_GRIPPERALWAYS = 0x00000080 }
                                                                                        >  2636  enum : uint { RBBS_NOGRIPPER = 0x00000100 }
                                                                                        >  2637  // #if (_WIN32_IE >= 0x0500)               //
                                                                                        >  2638  enum : uint { RBBS_USECHEVRON = 0x00000200 }
                                                                                        >  2639  // #if (_WIN32_IE >= 0x0501)               //
                                                                                        >  2640  enum : uint { RBBS_HIDETITLE = 0x00000400 }
                                                                                        >  2641  enum : uint { RBBS_TOPALIGN = 0x00000800 }
                                                                                        >  2642  // #endif // 0x0501                        //
                                                                                        >  2643  // #endif // 0x0500                        //
                                                                                        >  2644  // #endif // 0x0400                        //
                                                                                        >  2645  
                                                                                        >  2646  enum : uint { RBBIM_STYLE = 0x00000001 }
                                                                                        >  2647  enum : uint { RBBIM_COLORS = 0x00000002 }
                                                                                        >  2648  enum : uint { RBBIM_TEXT = 0x00000004 }
                                                                                        >  2649  enum : uint { RBBIM_IMAGE = 0x00000008 }
                                                                                        >  2650  enum : uint { RBBIM_CHILD = 0x00000010 }
                                                                                        >  2651  enum : uint { RBBIM_CHILDSIZE = 0x00000020 }
                                                                                        >  2652  enum : uint { RBBIM_SIZE = 0x00000040 }
                                                                                        >  2653  enum : uint { RBBIM_BACKGROUND = 0x00000080 }
                                                                                        >  2654  enum : uint { RBBIM_ID = 0x00000100 }
                                                                                        >  2655  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2656  enum : uint { RBBIM_IDEALSIZE = 0x00000200 }
                                                                                        >  2657  enum : uint { RBBIM_LPARAM = 0x00000400 }
                                                                                        >  2658  enum : uint { RBBIM_HEADERSIZE = 0x00000800 }
                                                                                        >  2659  // #endif
                                                                                        >  2660  
                                                                                        >  2661  struct tagREBARBANDINFOA {
                                                                                        >  2662    UINT cbSize;
                                                                                        >  2663    UINT fMask;
                                                                                        >  2664    UINT fStyle;
                                                                                        >  2665    COLORREF clrFore;
                                                                                        >  2666    COLORREF clrBack;
                                                                                        >  2667    LPSTR lpText;
                                                                                        >  2668    UINT cch;
                                                                                        >  2669    int iImage;
                                                                                        >  2670    HWND hwndChild;
                                                                                        >  2671    UINT cxMinChild;
                                                                                        >  2672    UINT cyMinChild;
                                                                                        >  2673    UINT cx;
                                                                                        >  2674    HBITMAP hbmBack;
                                                                                        >  2675    UINT wID;
                                                                                        >  2676  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2677    UINT cyChild;
                                                                                        >  2678    UINT cyMaxChild;
                                                                                        >  2679    UINT cyIntegral;
                                                                                        >  2680    UINT cxIdeal;
                                                                                        >  2681    LPARAM lParam;
                                                                                        >  2682    UINT cxHeader;
                                                                                        >  2683  // #endif
                                                                                        >  2684  }
                                                                                        >  2685  alias tagREBARBANDINFOA REBARBANDINFOA;
                                                                                        >  2686  alias tagREBARBANDINFOA* LPREBARBANDINFOA;
                                                                                        >  2687  
                                                                                        >  2688  alias REBARBANDINFOA* LPCREBARBANDINFOA;
                                                                                        >  2689  
                                                                                        >  2690  // #define REBARBANDINFOA_V3_SIZE CCSIZEOF_STRUCT(REBARBANDINFOA, wID)
                                                                                        >  2691  // #define REBARBANDINFOW_V3_SIZE CCSIZEOF_STRUCT(REBARBANDINFOW, wID)
                                                                                        >  2692  
                                                                                        >  2693  struct tagREBARBANDINFOW {
                                                                                        >  2694    UINT cbSize;
                                                                                        >  2695    UINT fMask;
                                                                                        >  2696    UINT fStyle;
                                                                                        >  2697    COLORREF clrFore;
                                                                                        >  2698    COLORREF clrBack;
                                                                                        >  2699    LPWSTR lpText;
                                                                                        >  2700    UINT cch;
                                                                                        >  2701    int iImage;
                                                                                        >  2702    HWND hwndChild;
                                                                                        >  2703    UINT cxMinChild;
                                                                                        >  2704    UINT cyMinChild;
                                                                                        >  2705    UINT cx;
                                                                                        >  2706    HBITMAP hbmBack;
                                                                                        >  2707    UINT wID;
                                                                                        >  2708  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2709    UINT cyChild;
                                                                                        >  2710    UINT cyMaxChild;
                                                                                        >  2711    UINT cyIntegral;
                                                                                        >  2712    UINT cxIdeal;
                                                                                        >  2713    LPARAM lParam;
                                                                                        >  2714    UINT cxHeader;
                                                                                        >  2715  // #endif
                                                                                        >  2716  }
                                                                                        >  2717  alias tagREBARBANDINFOW REBARBANDINFOW;
                                                                                        >  2718  alias tagREBARBANDINFOW* LPREBARBANDINFOW;
                                                                                        >  2719  
                                                                                        >  2720  alias REBARBANDINFOW* LPCREBARBANDINFOW;
                                                                                        >  2721  
                                                                                        >  2722  // #ifdef UNICODE
                                                                                        >  2723  // #...
                                                                                        >  2724  // #...
                                                                                        >  2725  // #...
                                                                                        >  2726  // #...
                                                                                        >  2727  // #else
                                                                                        >  2728  alias REBARBANDINFOA REBARBANDINFO;
                                                                                        >  2729  alias LPREBARBANDINFOA LPREBARBANDINFO;
                                                                                        >  2730  alias LPCREBARBANDINFOA LPCREBARBANDINFO;
                                                                                        >  2731  // #define REBARBANDINFO_V3_SIZE REBARBANDINFOA_V3_SIZE
                                                                                        >  2732  // #endif
                                                                                        >  2733  
                                                                                        >  2734  enum : uint { RB_INSERTBANDA = WM_USER + 1 }
                                                                                        >  2735  enum : uint { RB_DELETEBAND = WM_USER + 2 }
                                                                                        >  2736  enum : uint { RB_GETBARINFO = WM_USER + 3 }
                                                                                        >  2737  enum : uint { RB_SETBARINFO = WM_USER + 4 }
                                                                                        >  2738  // #if (_WIN32_IE < 0x0400)
                                                                                        >  2739  // #...
                                                                                        >  2740  // #endif
                                                                                        >  2741  enum : uint { RB_SETBANDINFOA = WM_USER + 6 }
                                                                                        >  2742  enum : uint { RB_SETPARENT = WM_USER + 7 }
                                                                                        >  2743  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2744  enum : uint { RB_HITTEST = WM_USER + 8 }
                                                                                        >  2745  enum : uint { RB_GETRECT = WM_USER + 9 }
                                                                                        >  2746  // #endif
                                                                                        >  2747  enum : uint { RB_INSERTBANDW = WM_USER + 10 }
                                                                                        >  2748  enum : uint { RB_SETBANDINFOW = WM_USER + 11 }
                                                                                        >  2749  enum : uint { RB_GETBANDCOUNT = WM_USER + 12 }
                                                                                        >  2750  enum : uint { RB_GETROWCOUNT = WM_USER + 13 }
                                                                                        >  2751  enum : uint { RB_GETROWHEIGHT = WM_USER + 14 }
                                                                                        >  2752  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2753  enum : uint { RB_IDTOINDEX = WM_USER + 16 }
                                                                                        >  2754  enum : uint { RB_GETTOOLTIPS = WM_USER + 17 }
                                                                                        >  2755  enum : uint { RB_SETTOOLTIPS = WM_USER + 18 }
                                                                                        >  2756  enum : uint { RB_SETBKCOLOR = WM_USER + 19 }
                                                                                        >  2757  enum : uint { RB_GETBKCOLOR = WM_USER + 20 }
                                                                                        >  2758  enum : uint { RB_SETTEXTCOLOR = WM_USER + 21 }
                                                                                        >  2759  enum : uint { RB_GETTEXTCOLOR = WM_USER + 22 }
                                                                                        >  2760  
                                                                                        >  2761  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  2762  enum : uint { RBSTR_CHANGERECT = 0x0001 }
                                                                                        >  2763  // #endif
                                                                                        >  2764  
                                                                                        >  2765  enum : uint { RB_SIZETORECT = WM_USER + 23 }
                                                                                        >  2766  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  2767  
                                                                                        >  2768  alias CCM_SETCOLORSCHEME RB_SETCOLORSCHEME;
                                                                                        >  2769  alias CCM_GETCOLORSCHEME RB_GETCOLORSCHEME;
                                                                                        >  2770  
                                                                                        >  2771  // #ifdef UNICODE
                                                                                        >  2772  // #...
                                                                                        >  2773  // #...
                                                                                        >  2774  // #else
                                                                                        >  2775  alias RB_INSERTBANDA RB_INSERTBAND;
                                                                                        >  2776  alias RB_SETBANDINFOA RB_SETBANDINFO;
                                                                                        >  2777  // #endif
                                                                                        >  2778  
                                                                                        >  2779  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2780  
                                                                                        >  2781  enum : uint { RB_BEGINDRAG = WM_USER + 24 }
                                                                                        >  2782  enum : uint { RB_ENDDRAG = WM_USER + 25 }
                                                                                        >  2783  enum : uint { RB_DRAGMOVE = WM_USER + 26 }
                                                                                        >  2784  enum : uint { RB_GETBARHEIGHT = WM_USER + 27 }
                                                                                        >  2785  enum : uint { RB_GETBANDINFOW = WM_USER + 28 }
                                                                                        >  2786  enum : uint { RB_GETBANDINFOA = WM_USER + 29 }
                                                                                        >  2787  
                                                                                        >  2788  // #ifdef UNICODE
                                                                                        >  2789  // #...
                                                                                        >  2790  // #else
                                                                                        >  2791  alias RB_GETBANDINFOA RB_GETBANDINFO;
                                                                                        >  2792  // #endif
                                                                                        >  2793  
                                                                                        >  2794  enum : uint { RB_MINIMIZEBAND = WM_USER + 30 }
                                                                                        >  2795  enum : uint { RB_MAXIMIZEBAND = WM_USER + 31 }
                                                                                        >  2796  
                                                                                        >  2797  enum : uint { RB_GETDROPTARGET = CCM_GETDROPTARGET }
                                                                                        >  2798  
                                                                                        >  2799  enum : uint { RB_GETBANDBORDERS = WM_USER + 34 }
                                                                                        >  2800  
                                                                                        >  2801  enum : uint { RB_SHOWBAND = WM_USER + 35 }
                                                                                        >  2802  enum : uint { RB_SETPALETTE = WM_USER + 37 }
                                                                                        >  2803  enum : uint { RB_GETPALETTE = WM_USER + 38 }
                                                                                        >  2804  enum : uint { RB_MOVEBAND = WM_USER + 39 }
                                                                                        >  2805  
                                                                                        >  2806  alias CCM_SETUNICODEFORMAT RB_SETUNICODEFORMAT;
                                                                                        >  2807  alias CCM_GETUNICODEFORMAT RB_GETUNICODEFORMAT;
                                                                                        >  2808  
                                                                                        >  2809  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  2810  
                                                                                        >  2811  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  2812  enum : uint { RB_GETBANDMARGINS = WM_USER + 40 }
                                                                                        >  2813  alias CCM_SETWINDOWTHEME RB_SETWINDOWTHEME;
                                                                                        >  2814  // #endif
                                                                                        >  2815  
                                                                                        >  2816  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2817  enum : uint { RB_PUSHCHEVRON = WM_USER + 43 }
                                                                                        >  2818  // #endif      // _WIN32_IE >= 0x0500
                                                                                        >  2819  
                                                                                        >  2820  enum : uint { RBN_HEIGHTCHANGE = RBN_FIRST - 0 }
                                                                                        >  2821  
                                                                                        >  2822  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  2823  enum : uint { RBN_GETOBJECT = RBN_FIRST - 1 }
                                                                                        >  2824  enum : uint { RBN_LAYOUTCHANGED = RBN_FIRST - 2 }
                                                                                        >  2825  enum : uint { RBN_AUTOSIZE = RBN_FIRST - 3 }
                                                                                        >  2826  enum : uint { RBN_BEGINDRAG = RBN_FIRST - 4 }
                                                                                        >  2827  enum : uint { RBN_ENDDRAG = RBN_FIRST - 5 }
                                                                                        >  2828  enum : uint { RBN_DELETINGBAND = RBN_FIRST - 6 }
                                                                                        >  2829  enum : uint { RBN_DELETEDBAND = RBN_FIRST - 7 }
                                                                                        >  2830  enum : uint { RBN_CHILDSIZE = RBN_FIRST - 8 }
                                                                                        >  2831  
                                                                                        >  2832  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2833  enum : uint { RBN_CHEVRONPUSHED = RBN_FIRST - 10 }
                                                                                        >  2834  // #endif      // _WIN32_IE >= 0x0500
                                                                                        >  2835  
                                                                                        >  2836  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2837  enum : uint { RBN_MINMAX = RBN_FIRST - 21 }
                                                                                        >  2838  // #endif
                                                                                        >  2839  
                                                                                        >  2840  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  2841  enum : uint { RBN_AUTOBREAK = RBN_FIRST - 22 }
                                                                                        >  2842  // #endif
                                                                                        >  2843  
                                                                                        >  2844  struct tagNMREBARCHILDSIZE {
                                                                                        >  2845    NMHDR hdr;
                                                                                        >  2846    UINT uBand;
                                                                                        >  2847    UINT wID;
                                                                                        >  2848    RECT rcChild;
                                                                                        >  2849    RECT rcBand;
                                                                                        >  2850  }
                                                                                        >  2851  alias tagNMREBARCHILDSIZE NMREBARCHILDSIZE;
                                                                                        >  2852  alias tagNMREBARCHILDSIZE* LPNMREBARCHILDSIZE;
                                                                                        >  2853  
                                                                                        >  2854  struct tagNMREBAR {
                                                                                        >  2855    NMHDR hdr;
                                                                                        >  2856    DWORD dwMask;
                                                                                        >  2857    UINT uBand;
                                                                                        >  2858    UINT fStyle;
                                                                                        >  2859    UINT wID;
                                                                                        >  2860    LPARAM lParam;
                                                                                        >  2861  }
                                                                                        >  2862  alias tagNMREBAR NMREBAR;
                                                                                        >  2863  alias tagNMREBAR* LPNMREBAR;
                                                                                        >  2864  
                                                                                        >  2865  enum : uint { RBNM_ID = 0x00000001 }
                                                                                        >  2866  enum : uint { RBNM_STYLE = 0x00000002 }
                                                                                        >  2867  enum : uint { RBNM_LPARAM = 0x00000004 }
                                                                                        >  2868  
                                                                                        >  2869  struct tagNMRBAUTOSIZE {
                                                                                        >  2870    NMHDR hdr;
                                                                                        >  2871    BOOL fChanged;
                                                                                        >  2872    RECT rcTarget;
                                                                                        >  2873    RECT rcActual;
                                                                                        >  2874  }
                                                                                        >  2875  alias tagNMRBAUTOSIZE NMRBAUTOSIZE;
                                                                                        >  2876  alias tagNMRBAUTOSIZE* LPNMRBAUTOSIZE;
                                                                                        >  2877  
                                                                                        >  2878  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2879  struct tagNMREBARCHEVRON {
                                                                                        >  2880    NMHDR hdr;
                                                                                        >  2881    UINT uBand;
                                                                                        >  2882    UINT wID;
                                                                                        >  2883    LPARAM lParam;
                                                                                        >  2884    RECT rc;
                                                                                        >  2885    LPARAM lParamNM;
                                                                                        >  2886  }
                                                                                        >  2887  alias tagNMREBARCHEVRON NMREBARCHEVRON;
                                                                                        >  2888  alias tagNMREBARCHEVRON* LPNMREBARCHEVRON;
                                                                                        >  2889  
                                                                                        >  2890  // #endif
                                                                                        >  2891  
                                                                                        >  2892  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  2893  enum : uint { RBAB_AUTOSIZE = 0x0001 }
                                                                                        >  2894  enum : uint { RBAB_ADDBAND = 0x0002 }
                                                                                        >  2895  
                                                                                        >  2896  struct tagNMREBARAUTOBREAK {
                                                                                        >  2897    NMHDR hdr;
                                                                                        >  2898    UINT uBand;
                                                                                        >  2899    UINT wID;
                                                                                        >  2900    LPARAM lParam;
                                                                                        >  2901    UINT uMsg;
                                                                                        >  2902    UINT fStyleCurrent;
                                                                                        >  2903    BOOL fAutoBreak;
                                                                                        >  2904  }
                                                                                        >  2905  alias tagNMREBARAUTOBREAK NMREBARAUTOBREAK;
                                                                                        >  2906  alias tagNMREBARAUTOBREAK* LPNMREBARAUTOBREAK;
                                                                                        >  2907  
                                                                                        >  2908  // #endif
                                                                                        >  2909  
                                                                                        >  2910  enum : uint { RBHT_NOWHERE = 0x0001 }
                                                                                        >  2911  enum : uint { RBHT_CAPTION = 0x0002 }
                                                                                        >  2912  enum : uint { RBHT_CLIENT = 0x0003 }
                                                                                        >  2913  enum : uint { RBHT_GRABBER = 0x0004 }
                                                                                        >  2914  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  2915  enum : uint { RBHT_CHEVRON = 0x0008 }
                                                                                        >  2916  // #endif
                                                                                        >  2917  
                                                                                        >  2918  struct _RB_HITTESTINFO {
                                                                                        >  2919    POINT pt;
                                                                                        >  2920    UINT flags;
                                                                                        >  2921    int iBand;
                                                                                        >  2922  }
                                                                                        >  2923  alias _RB_HITTESTINFO RBHITTESTINFO;
                                                                                        >  2924  alias _RB_HITTESTINFO* LPRBHITTESTINFO;
                                                                                        >  2925  
                                                                                        >  2926  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  2927  
                                                                                        >  2928  // #endif      // NOREBAR
                                                                                        >  2929  
                                                                                        >  2930  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  2931  
                                                                                        >  2932  // #ifndef NOTOOLTIPS
                                                                                        >  2933  
                                                                                        >  2934  // #ifdef _WIN32
                                                                                        >  2935  
                                                                                        >  2936  const wchar[] TOOLTIPS_CLASSW = "tooltips_class32";
                                                                                        >  2937  const char[] TOOLTIPS_CLASSA = "tooltips_class32";
                                                                                        >  2938  
                                                                                        >  2939  // #ifdef UNICODE
                                                                                        >  2940  // #...
                                                                                        >  2941  // #else
                                                                                        >  2942  alias TOOLTIPS_CLASSA TOOLTIPS_CLASS;
                                                                                        >  2943  // #endif
                                                                                        >  2944  
                                                                                        >  2945  // #else
                                                                                        >  2946  // #...
                                                                                        >  2947  // #endif
                                                                                        >  2948  
                                                                                        >  2949  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2950  alias LPTTTOOLINFOA LPTOOLINFOA;
                                                                                        >  2951  alias LPTTTOOLINFOW LPTOOLINFOW;
                                                                                        >  2952  alias TTTOOLINFOA TOOLINFOA;
                                                                                        >  2953  alias TTTOOLINFOW TOOLINFOW;
                                                                                        >  2954  // #else
                                                                                        >  2955  // #...
                                                                                        >  2956  // #...
                                                                                        >  2957  // #...
                                                                                        >  2958  // #...
                                                                                        >  2959  // #endif
                                                                                        >  2960  
                                                                                        >  2961  alias LPTTTOOLINFO LPTOOLINFO;
                                                                                        >  2962  alias TTTOOLINFO TOOLINFO;
                                                                                        >  2963  
                                                                                        >  2964  // #define TTTOOLINFOA_V1_SIZE CCSIZEOF_STRUCT(TTTOOLINFOA, lpszText)
                                                                                        >  2965  // #define TTTOOLINFOW_V1_SIZE CCSIZEOF_STRUCT(TTTOOLINFOW, lpszText)
                                                                                        >  2966  // #define TTTOOLINFOA_V2_SIZE CCSIZEOF_STRUCT(TTTOOLINFOA, lParam)
                                                                                        >  2967  // #define TTTOOLINFOW_V2_SIZE CCSIZEOF_STRUCT(TTTOOLINFOW, lParam)
                                                                                        >  2968  // #define TTTOOLINFOA_V3_SIZE CCSIZEOF_STRUCT(TTTOOLINFOA, lpReserved)
                                                                                        >  2969  // #define TTTOOLINFOW_V3_SIZE CCSIZEOF_STRUCT(TTTOOLINFOW, lpReserved)
                                                                                        >  2970  
                                                                                        >  2971  struct tagTOOLINFOA {
                                                                                        >  2972    UINT cbSize;
                                                                                        >  2973    UINT uFlags;
                                                                                        >  2974    HWND hwnd;
                                                                                        >  2975    UINT_PTR uId;
                                                                                        >  2976    RECT rect;
                                                                                        >  2977    HINSTANCE hinst;
                                                                                        >  2978    LPSTR lpszText;
                                                                                        >  2979  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2980    LPARAM lParam;
                                                                                        >  2981  // #endif
                                                                                        >  2982  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  2983    void *lpReserved;
                                                                                        >  2984  // #endif
                                                                                        >  2985  }
                                                                                        >  2986  alias tagTOOLINFOA TTTOOLINFOA;
                                                                                        >  2987  alias tagTOOLINFOA* PTOOLINFOA;
                                                                                        >  2988  alias tagTOOLINFOA* LPTTTOOLINFOA;
                                                                                        >  2989  
                                                                                        >  2990  struct tagTOOLINFOW {
                                                                                        >  2991    UINT cbSize;
                                                                                        >  2992    UINT uFlags;
                                                                                        >  2993    HWND hwnd;
                                                                                        >  2994    UINT_PTR uId;
                                                                                        >  2995    RECT rect;
                                                                                        >  2996    HINSTANCE hinst;
                                                                                        >  2997    LPWSTR lpszText;
                                                                                        >  2998  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  2999    LPARAM lParam;
                                                                                        >  3000  // #endif
                                                                                        >  3001  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  3002    void *lpReserved;
                                                                                        >  3003  // #endif
                                                                                        >  3004  }
                                                                                        >  3005  alias tagTOOLINFOW TTTOOLINFOW;
                                                                                        >  3006  alias tagTOOLINFOW* PTOOLINFOW;
                                                                                        >  3007  alias tagTOOLINFOW* LPTTTOOLINFOW;
                                                                                        >  3008  
                                                                                        >  3009  // #ifdef UNICODE
                                                                                        >  3010  // #...
                                                                                        >  3011  // #...
                                                                                        >  3012  // #...
                                                                                        >  3013  // #...
                                                                                        >  3014  // #else
                                                                                        >  3015  alias PTOOLINFOA PTOOLINFO;
                                                                                        >  3016  alias TTTOOLINFOA TTTOOLINFO;
                                                                                        >  3017  alias LPTTTOOLINFOA LPTTTOOLINFO;
                                                                                        >  3018  // #define TTTOOLINFO_V1_SIZE TTTOOLINFOA_V1_SIZE
                                                                                        >  3019  // #endif
                                                                                        >  3020  
                                                                                        >  3021  enum : uint { TTS_ALWAYSTIP = 0x01 }
                                                                                        >  3022  enum : uint { TTS_NOPREFIX = 0x02 }
                                                                                        >  3023  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3024  enum : uint { TTS_NOANIMATE = 0x10 }
                                                                                        >  3025  enum : uint { TTS_NOFADE = 0x20 }
                                                                                        >  3026  enum : uint { TTS_BALLOON = 0x40 }
                                                                                        >  3027  enum : uint { TTS_CLOSE = 0x80 }
                                                                                        >  3028  // #endif
                                                                                        >  3029  
                                                                                        >  3030  enum : uint { TTF_IDISHWND = 0x0001 }
                                                                                        >  3031  
                                                                                        >  3032  enum : uint { TTF_CENTERTIP = 0x0002 }
                                                                                        >  3033  enum : uint { TTF_RTLREADING = 0x0004 }
                                                                                        >  3034  enum : uint { TTF_SUBCLASS = 0x0010 }
                                                                                        >  3035  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3036  enum : uint { TTF_TRACK = 0x0020 }
                                                                                        >  3037  enum : uint { TTF_ABSOLUTE = 0x0080 }
                                                                                        >  3038  enum : uint { TTF_TRANSPARENT = 0x0100 }
                                                                                        >  3039  // #if (_WIN32_IE >= 0x0501)
                                                                                        >  3040  enum : uint { TTF_PARSELINKS = 0x1000 }
                                                                                        >  3041  // #endif // _WIN32_IE >= 0x0501
                                                                                        >  3042  enum : uint { TTF_DI_SETITEM = 0x8000 }
                                                                                        >  3043  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  3044  
                                                                                        >  3045  enum : uint { TTDT_AUTOMATIC = 0 }
                                                                                        >  3046  enum : uint { TTDT_RESHOW = 1 }
                                                                                        >  3047  enum : uint { TTDT_AUTOPOP = 2 }
                                                                                        >  3048  enum : uint { TTDT_INITIAL = 3 }
                                                                                        >  3049  
                                                                                        >  3050  enum : uint { TTI_NONE = 0 }
                                                                                        >  3051  enum : uint { TTI_INFO = 1 }
                                                                                        >  3052  enum : uint { TTI_WARNING = 2 }
                                                                                        >  3053  enum : uint { TTI_ERROR = 3 }
                                                                                        >  3054  
                                                                                        >  3055  enum : uint { TTM_ACTIVATE = WM_USER + 1 }
                                                                                        >  3056  enum : uint { TTM_SETDELAYTIME = WM_USER + 3 }
                                                                                        >  3057  enum : uint { TTM_ADDTOOLA = WM_USER + 4 }
                                                                                        >  3058  enum : uint { TTM_ADDTOOLW = WM_USER + 50 }
                                                                                        >  3059  enum : uint { TTM_DELTOOLA = WM_USER + 5 }
                                                                                        >  3060  enum : uint { TTM_DELTOOLW = WM_USER + 51 }
                                                                                        >  3061  enum : uint { TTM_NEWTOOLRECTA = WM_USER + 6 }
                                                                                        >  3062  enum : uint { TTM_NEWTOOLRECTW = WM_USER + 52 }
                                                                                        >  3063  enum : uint { TTM_RELAYEVENT = WM_USER + 7 }
                                                                                        >  3064  
                                                                                        >  3065  enum : uint { TTM_GETTOOLINFOA = WM_USER + 8 }
                                                                                        >  3066  enum : uint { TTM_GETTOOLINFOW = WM_USER + 53 }
                                                                                        >  3067  
                                                                                        >  3068  enum : uint { TTM_SETTOOLINFOA = WM_USER + 9 }
                                                                                        >  3069  enum : uint { TTM_SETTOOLINFOW = WM_USER + 54 }
                                                                                        >  3070  
                                                                                        >  3071  enum : uint { TTM_HITTESTA = WM_USER +10 }
                                                                                        >  3072  enum : uint { TTM_HITTESTW = WM_USER +55 }
                                                                                        >  3073  enum : uint { TTM_GETTEXTA = WM_USER +11 }
                                                                                        >  3074  enum : uint { TTM_GETTEXTW = WM_USER +56 }
                                                                                        >  3075  enum : uint { TTM_UPDATETIPTEXTA = WM_USER +12 }
                                                                                        >  3076  enum : uint { TTM_UPDATETIPTEXTW = WM_USER +57 }
                                                                                        >  3077  enum : uint { TTM_GETTOOLCOUNT = WM_USER +13 }
                                                                                        >  3078  enum : uint { TTM_ENUMTOOLSA = WM_USER +14 }
                                                                                        >  3079  enum : uint { TTM_ENUMTOOLSW = WM_USER +58 }
                                                                                        >  3080  enum : uint { TTM_GETCURRENTTOOLA = WM_USER + 15 }
                                                                                        >  3081  enum : uint { TTM_GETCURRENTTOOLW = WM_USER + 59 }
                                                                                        >  3082  enum : uint { TTM_WINDOWFROMPOINT = WM_USER + 16 }
                                                                                        >  3083  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3084  enum : uint { TTM_TRACKACTIVATE = WM_USER + 17 }
                                                                                        >  3085  enum : uint { TTM_TRACKPOSITION = WM_USER + 18 }
                                                                                        >  3086  enum : uint { TTM_SETTIPBKCOLOR = WM_USER + 19 }
                                                                                        >  3087  enum : uint { TTM_SETTIPTEXTCOLOR = WM_USER + 20 }
                                                                                        >  3088  enum : uint { TTM_GETDELAYTIME = WM_USER + 21 }
                                                                                        >  3089  enum : uint { TTM_GETTIPBKCOLOR = WM_USER + 22 }
                                                                                        >  3090  enum : uint { TTM_GETTIPTEXTCOLOR = WM_USER + 23 }
                                                                                        >  3091  enum : uint { TTM_SETMAXTIPWIDTH = WM_USER + 24 }
                                                                                        >  3092  enum : uint { TTM_GETMAXTIPWIDTH = WM_USER + 25 }
                                                                                        >  3093  enum : uint { TTM_SETMARGIN = WM_USER + 26 }
                                                                                        >  3094  enum : uint { TTM_GETMARGIN = WM_USER + 27 }
                                                                                        >  3095  enum : uint { TTM_POP = WM_USER + 28 }
                                                                                        >  3096  // #endif
                                                                                        >  3097  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3098  enum : uint { TTM_UPDATE = WM_USER + 29 }
                                                                                        >  3099  // #endif
                                                                                        >  3100  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3101  enum : uint { TTM_GETBUBBLESIZE = WM_USER + 30 }
                                                                                        >  3102  enum : uint { TTM_ADJUSTRECT = WM_USER + 31 }
                                                                                        >  3103  enum : uint { TTM_SETTITLEA = WM_USER + 32 }
                                                                                        >  3104  enum : uint { TTM_SETTITLEW = WM_USER + 33 }
                                                                                        >  3105  // #endif
                                                                                        >  3106  
                                                                                        >  3107  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  3108  enum : uint { TTM_POPUP = WM_USER + 34 }
                                                                                        >  3109  enum : uint { TTM_GETTITLE = WM_USER + 35 }
                                                                                        >  3110  
                                                                                        >  3111  struct _TTGETTITLE {
                                                                                        >  3112    DWORD dwSize;
                                                                                        >  3113    UINT uTitleBitmap;
                                                                                        >  3114    UINT cch;
                                                                                        >  3115    WCHAR * pszTitle;
                                                                                        >  3116  }
                                                                                        >  3117  alias _TTGETTITLE TTGETTITLE;
                                                                                        >  3118  alias _TTGETTITLE* PTTGETTITLE;
                                                                                        >  3119  
                                                                                        >  3120  // #endif
                                                                                        >  3121  
                                                                                        >  3122  // #ifdef UNICODE
                                                                                        >  3123  // #...
                                                                                        >  3124  // #...
                                                                                        >  3125  // #...
                                                                                        >  3126  // #...
                                                                                        >  3127  // #...
                                                                                        >  3128  // #...
                                                                                        >  3129  // #...
                                                                                        >  3130  // #...
                                                                                        >  3131  // #...
                                                                                        >  3132  // #...
                                                                                        >  3133  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3134  // #...
                                                                                        >  3135  // #endif
                                                                                        >  3136  // #else
                                                                                        >  3137  alias TTM_ADDTOOLA TTM_ADDTOOL;
                                                                                        >  3138  alias TTM_DELTOOLA TTM_DELTOOL;
                                                                                        >  3139  alias TTM_NEWTOOLRECTA TTM_NEWTOOLRECT;
                                                                                        >  3140  alias TTM_GETTOOLINFOA TTM_GETTOOLINFO;
                                                                                        >  3141  alias TTM_SETTOOLINFOA TTM_SETTOOLINFO;
                                                                                        >  3142  alias TTM_HITTESTA TTM_HITTEST;
                                                                                        >  3143  alias TTM_GETTEXTA TTM_GETTEXT;
                                                                                        >  3144  alias TTM_UPDATETIPTEXTA TTM_UPDATETIPTEXT;
                                                                                        >  3145  alias TTM_ENUMTOOLSA TTM_ENUMTOOLS;
                                                                                        >  3146  alias TTM_GETCURRENTTOOLA TTM_GETCURRENTTOOL;
                                                                                        >  3147  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3148  alias TTM_SETTITLEA TTM_SETTITLE;
                                                                                        >  3149  // #endif
                                                                                        >  3150  // #endif
                                                                                        >  3151  
                                                                                        >  3152  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  3153  alias CCM_SETWINDOWTHEME TTM_SETWINDOWTHEME;
                                                                                        >  3154  // #endif
                                                                                        >  3155  
                                                                                        >  3156  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3157  alias LPTTHITTESTINFOW LPHITTESTINFOW;
                                                                                        >  3158  alias LPTTHITTESTINFOA LPHITTESTINFOA;
                                                                                        >  3159  // #else
                                                                                        >  3160  // #...
                                                                                        >  3161  // #...
                                                                                        >  3162  // #endif
                                                                                        >  3163  
                                                                                        >  3164  alias LPTTHITTESTINFO LPHITTESTINFO;
                                                                                        >  3165  
                                                                                        >  3166  struct _TT_HITTESTINFOA {
                                                                                        >  3167    HWND hwnd;
                                                                                        >  3168    POINT pt;
                                                                                        >  3169    TTTOOLINFOA ti;
                                                                                        >  3170  }
                                                                                        >  3171  alias _TT_HITTESTINFOA TTHITTESTINFOA;
                                                                                        >  3172  alias _TT_HITTESTINFOA* LPTTHITTESTINFOA;
                                                                                        >  3173  
                                                                                        >  3174  struct _TT_HITTESTINFOW {
                                                                                        >  3175    HWND hwnd;
                                                                                        >  3176    POINT pt;
                                                                                        >  3177    TTTOOLINFOW ti;
                                                                                        >  3178  }
                                                                                        >  3179  alias _TT_HITTESTINFOW TTHITTESTINFOW;
                                                                                        >  3180  alias _TT_HITTESTINFOW* LPTTHITTESTINFOW;
                                                                                        >  3181  
                                                                                        >  3182  // #ifdef UNICODE
                                                                                        >  3183  // #...
                                                                                        >  3184  // #...
                                                                                        >  3185  // #else
                                                                                        >  3186  alias TTHITTESTINFOA TTHITTESTINFO;
                                                                                        >  3187  alias LPTTHITTESTINFOA LPTTHITTESTINFO;
                                                                                        >  3188  // #endif
                                                                                        >  3189  
                                                                                        >  3190  enum : uint { TTN_GETDISPINFOA = TTN_FIRST - 0 }
                                                                                        >  3191  enum : uint { TTN_GETDISPINFOW = TTN_FIRST - 10 }
                                                                                        >  3192  enum : uint { TTN_SHOW = TTN_FIRST - 1 }
                                                                                        >  3193  enum : uint { TTN_POP = TTN_FIRST - 2 }
                                                                                        >  3194  enum : uint { TTN_LINKCLICK = TTN_FIRST - 3 }
                                                                                        >  3195  
                                                                                        >  3196  // #ifdef UNICODE
                                                                                        >  3197  // #...
                                                                                        >  3198  // #else
                                                                                        >  3199  alias TTN_GETDISPINFOA TTN_GETDISPINFO;
                                                                                        >  3200  // #endif
                                                                                        >  3201  
                                                                                        >  3202  alias TTN_GETDISPINFO TTN_NEEDTEXT;
                                                                                        >  3203  alias TTN_GETDISPINFOA TTN_NEEDTEXTA;
                                                                                        >  3204  alias TTN_GETDISPINFOW TTN_NEEDTEXTW;
                                                                                        >  3205  
                                                                                        >  3206  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3207  alias NMTTDISPINFOW TOOLTIPTEXTW;
                                                                                        >  3208  alias NMTTDISPINFOA TOOLTIPTEXTA;
                                                                                        >  3209  alias LPNMTTDISPINFOA LPTOOLTIPTEXTA;
                                                                                        >  3210  alias LPNMTTDISPINFOW LPTOOLTIPTEXTW;
                                                                                        >  3211  // #else
                                                                                        >  3212  // #...
                                                                                        >  3213  // #...
                                                                                        >  3214  // #...
                                                                                        >  3215  // #...
                                                                                        >  3216  // #...
                                                                                        >  3217  // #...
                                                                                        >  3218  // #endif
                                                                                        >  3219  
                                                                                        >  3220  alias NMTTDISPINFO TOOLTIPTEXT;
                                                                                        >  3221  alias LPNMTTDISPINFO LPTOOLTIPTEXT;
                                                                                        >  3222  
                                                                                        >  3223  // #define NMTTDISPINFOA_V1_SIZE CCSIZEOF_STRUCT(NMTTDISPINFOA, uFlags)
                                                                                        >  3224  // #define NMTTDISPINFOW_V1_SIZE CCSIZEOF_STRUCT(NMTTDISPINFOW, uFlags)
                                                                                        >  3225  
                                                                                        >  3226  struct tagNMTTDISPINFOA {
                                                                                        >  3227    NMHDR hdr;
                                                                                        >  3228    LPSTR lpszText;
                                                                                        >  3229    char szText[80];
                                                                                        >  3230    HINSTANCE hinst;
                                                                                        >  3231    UINT uFlags;
                                                                                        >  3232  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3233    LPARAM lParam;
                                                                                        >  3234  // #endif
                                                                                        >  3235  }
                                                                                        >  3236  alias tagNMTTDISPINFOA NMTTDISPINFOA;
                                                                                        >  3237  alias tagNMTTDISPINFOA* LPNMTTDISPINFOA;
                                                                                        >  3238  
                                                                                        >  3239  struct tagNMTTDISPINFOW {
                                                                                        >  3240    NMHDR hdr;
                                                                                        >  3241    LPWSTR lpszText;
                                                                                        >  3242    WCHAR szText[80];
                                                                                        >  3243    HINSTANCE hinst;
                                                                                        >  3244    UINT uFlags;
                                                                                        >  3245  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3246    LPARAM lParam;
                                                                                        >  3247  // #endif
                                                                                        >  3248  }
                                                                                        >  3249  alias tagNMTTDISPINFOW NMTTDISPINFOW;
                                                                                        >  3250  alias tagNMTTDISPINFOW* LPNMTTDISPINFOW;
                                                                                        >  3251  
                                                                                        >  3252  // #ifdef UNICODE
                                                                                        >  3253  // #...
                                                                                        >  3254  // #...
                                                                                        >  3255  // #...
                                                                                        >  3256  // #else
                                                                                        >  3257  alias NMTTDISPINFOA NMTTDISPINFO;
                                                                                        >  3258  alias LPNMTTDISPINFOA LPNMTTDISPINFO;
                                                                                        >  3259  // #define NMTTDISPINFO_V1_SIZE NMTTDISPINFOA_V1_SIZE
                                                                                        >  3260  // #endif
                                                                                        >  3261  
                                                                                        >  3262  // #endif      // NOTOOLTIPS
                                                                                        >  3263  
                                                                                        >  3264  // #ifndef NOSTATUSBAR
                                                                                        >  3265  
                                                                                        >  3266  enum : uint { SBARS_SIZEGRIP = 0x0100 }
                                                                                        >  3267  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3268  enum : uint { SBARS_TOOLTIPS = 0x0800 }
                                                                                        >  3269  // #endif
                                                                                        >  3270  
                                                                                        >  3271  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3272  
                                                                                        >  3273  enum : uint { SBT_TOOLTIPS = 0x0800 }
                                                                                        >  3274  // #endif
                                                                                        >  3275  
                                                                                        >  3276  extern(Windows) export void DrawStatusTextA(HDC hDC, LPRECT lprc, LPCSTR pszText
                                                                                        >  3277  extern(Windows) export void DrawStatusTextW(HDC hDC, LPRECT lprc, LPCWSTR pszTex
                                                                                        >  3278  
                                                                                        >  3279  extern(Windows) export HWND CreateStatusWindowA(LONG style, LPCSTR lpszText, HWN
                                                                                        >  3280  extern(Windows) export HWND CreateStatusWindowW(LONG style, LPCWSTR lpszText, HW
                                                                                        >  3281  
                                                                                        >  3282  // #ifdef UNICODE
                                                                                        >  3283  // #...
                                                                                        >  3284  // #...
                                                                                        >  3285  // #else
                                                                                        >  3286  alias CreateStatusWindowA CreateStatusWindow;
                                                                                        >  3287  alias DrawStatusTextA DrawStatusText;
                                                                                        >  3288  // #endif
                                                                                        >  3289  
                                                                                        >  3290  // #ifdef _WIN32
                                                                                        >  3291  const wchar[] STATUSCLASSNAMEW = "msctls_statusbar32";
                                                                                        >  3292  const char[] STATUSCLASSNAMEA = "msctls_statusbar32";
                                                                                        >  3293  
                                                                                        >  3294  // #ifdef UNICODE
                                                                                        >  3295  // #...
                                                                                        >  3296  // #else
                                                                                        >  3297  alias STATUSCLASSNAMEA STATUSCLASSNAME;
                                                                                        >  3298  // #endif
                                                                                        >  3299  
                                                                                        >  3300  // #else
                                                                                        >  3301  // #...
                                                                                        >  3302  // #endif
                                                                                        >  3303  
                                                                                        >  3304  enum : uint { SB_SETTEXTA = WM_USER+1 }
                                                                                        >  3305  enum : uint { SB_SETTEXTW = WM_USER+11 }
                                                                                        >  3306  enum : uint { SB_GETTEXTA = WM_USER+2 }
                                                                                        >  3307  enum : uint { SB_GETTEXTW = WM_USER+13 }
                                                                                        >  3308  enum : uint { SB_GETTEXTLENGTHA = WM_USER+3 }
                                                                                        >  3309  enum : uint { SB_GETTEXTLENGTHW = WM_USER+12 }
                                                                                        >  3310  
                                                                                        >  3311  // #ifdef UNICODE
                                                                                        >  3312  // #...
                                                                                        >  3313  // #...
                                                                                        >  3314  // #...
                                                                                        >  3315  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3316  // #...
                                                                                        >  3317  // #...
                                                                                        >  3318  // #endif
                                                                                        >  3319  // #else
                                                                                        >  3320  alias SB_GETTEXTA SB_GETTEXT;
                                                                                        >  3321  alias SB_SETTEXTA SB_SETTEXT;
                                                                                        >  3322  alias SB_GETTEXTLENGTHA SB_GETTEXTLENGTH;
                                                                                        >  3323  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3324  alias SB_SETTIPTEXTA SB_SETTIPTEXT;
                                                                                        >  3325  alias SB_GETTIPTEXTA SB_GETTIPTEXT;
                                                                                        >  3326  // #endif
                                                                                        >  3327  // #endif
                                                                                        >  3328  
                                                                                        >  3329  enum : uint { SB_SETPARTS = WM_USER+4 }
                                                                                        >  3330  enum : uint { SB_GETPARTS = WM_USER+6 }
                                                                                        >  3331  enum : uint { SB_GETBORDERS = WM_USER+7 }
                                                                                        >  3332  enum : uint { SB_SETMINHEIGHT = WM_USER+8 }
                                                                                        >  3333  enum : uint { SB_SIMPLE = WM_USER+9 }
                                                                                        >  3334  enum : uint { SB_GETRECT = WM_USER+10 }
                                                                                        >  3335  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3336  enum : uint { SB_ISSIMPLE = WM_USER+14 }
                                                                                        >  3337  // #endif
                                                                                        >  3338  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3339  enum : uint { SB_SETICON = WM_USER+15 }
                                                                                        >  3340  // #define SB_SETTIPTEXTA (WM_USER+16)
                                                                                        >  3341  // #define SB_SETTIPTEXTW (WM_USER+17)
                                                                                        >  3342  // #define SB_GETTIPTEXTA (WM_USER+18)
                                                                                        >  3343  // #define SB_GETTIPTEXTW (WM_USER+19)
                                                                                        >  3344  enum : uint { SB_GETICON = WM_USER+20 }
                                                                                        >  3345  alias CCM_SETUNICODEFORMAT SB_SETUNICODEFORMAT;
                                                                                        >  3346  alias CCM_GETUNICODEFORMAT SB_GETUNICODEFORMAT;
                                                                                        >  3347  // #endif
                                                                                        >  3348  
                                                                                        >  3349  enum : uint { SBT_OWNERDRAW = 0x1000 }
                                                                                        >  3350  enum : uint { SBT_NOBORDERS = 0x0100 }
                                                                                        >  3351  enum : uint { SBT_POPOUT = 0x0200 }
                                                                                        >  3352  enum : uint { SBT_RTLREADING = 0x0400 }
                                                                                        >  3353  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3354  enum : uint { SBT_NOTABPARSING = 0x0800 }
                                                                                        >  3355  // #endif
                                                                                        >  3356  
                                                                                        >  3357  alias CCM_SETBKCOLOR SB_SETBKCOLOR;
                                                                                        >  3358  
                                                                                        >  3359  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3360  enum : uint { SBN_SIMPLEMODECHANGE = SBN_FIRST - 0 }
                                                                                        >  3361  // #endif
                                                                                        >  3362  
                                                                                        >  3363  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3364  
                                                                                        >  3365  enum : uint { SB_SIMPLEID = 0x00ff }
                                                                                        >  3366  // #endif
                                                                                        >  3367  
                                                                                        >  3368  // #endif      // NOSTATUSBAR
                                                                                        >  3369  
                                                                                        >  3370  // #ifndef NOMENUHELP
                                                                                        >  3371  
                                                                                        >  3372  extern(Windows) export void MenuHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, HM
                                                                                        >  3373  extern(Windows) export BOOL ShowHideMenuCtl(HWND hWnd, UINT_PTR uFlags, LPINT lp
                                                                                        >  3374  extern(Windows) export void GetEffectiveClientRect(HWND hWnd, LPRECT lprc, LPINT
                                                                                        >  3375  
                                                                                        >  3376  alias SC_SIZE MINSYSCOMMAND;
                                                                                        >  3377  
                                                                                        >  3378  // #endif
                                                                                        >  3379  
                                                                                        >  3380  // #ifndef NOTRACKBAR
                                                                                        >  3381  
                                                                                        >  3382  // #ifdef _WIN32
                                                                                        >  3383  
                                                                                        >  3384  const char[] TRACKBAR_CLASSA = "msctls_trackbar32";
                                                                                        >  3385  const wchar[] TRACKBAR_CLASSW = "msctls_trackbar32";
                                                                                        >  3386  
                                                                                        >  3387  // #ifdef UNICODE
                                                                                        >  3388  // #...
                                                                                        >  3389  // #else
                                                                                        >  3390  alias TRACKBAR_CLASSA TRACKBAR_CLASS;
                                                                                        >  3391  // #endif
                                                                                        >  3392  
                                                                                        >  3393  // #else
                                                                                        >  3394  // #...
                                                                                        >  3395  // #endif
                                                                                        >  3396  
                                                                                        >  3397  enum : uint { TBS_AUTOTICKS = 0x0001 }
                                                                                        >  3398  enum : uint { TBS_VERT = 0x0002 }
                                                                                        >  3399  enum : uint { TBS_HORZ = 0x0000 }
                                                                                        >  3400  enum : uint { TBS_TOP = 0x0004 }
                                                                                        >  3401  enum : uint { TBS_BOTTOM = 0x0000 }
                                                                                        >  3402  enum : uint { TBS_LEFT = 0x0004 }
                                                                                        >  3403  enum : uint { TBS_RIGHT = 0x0000 }
                                                                                        >  3404  enum : uint { TBS_BOTH = 0x0008 }
                                                                                        >  3405  enum : uint { TBS_NOTICKS = 0x0010 }
                                                                                        >  3406  enum : uint { TBS_ENABLESELRANGE = 0x0020 }
                                                                                        >  3407  enum : uint { TBS_FIXEDLENGTH = 0x0040 }
                                                                                        >  3408  enum : uint { TBS_NOTHUMB = 0x0080 }
                                                                                        >  3409  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3410  enum : uint { TBS_TOOLTIPS = 0x0100 }
                                                                                        >  3411  // #endif
                                                                                        >  3412  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3413  enum : uint { TBS_REVERSED = 0x0200 }
                                                                                        >  3414  // #endif
                                                                                        >  3415  
                                                                                        >  3416  // #if (_WIN32_IE >= 0x0501)
                                                                                        >  3417  enum : uint { TBS_DOWNISLEFT = 0x0400 }
                                                                                        >  3418  // #endif
                                                                                        >  3419  
                                                                                        >  3420  enum : uint { TBM_GETPOS = WM_USER }
                                                                                        >  3421  enum : uint { TBM_GETRANGEMIN = WM_USER+1 }
                                                                                        >  3422  enum : uint { TBM_GETRANGEMAX = WM_USER+2 }
                                                                                        >  3423  enum : uint { TBM_GETTIC = WM_USER+3 }
                                                                                        >  3424  enum : uint { TBM_SETTIC = WM_USER+4 }
                                                                                        >  3425  enum : uint { TBM_SETPOS = WM_USER+5 }
                                                                                        >  3426  enum : uint { TBM_SETRANGE = WM_USER+6 }
                                                                                        >  3427  enum : uint { TBM_SETRANGEMIN = WM_USER+7 }
                                                                                        >  3428  enum : uint { TBM_SETRANGEMAX = WM_USER+8 }
                                                                                        >  3429  enum : uint { TBM_CLEARTICS = WM_USER+9 }
                                                                                        >  3430  enum : uint { TBM_SETSEL = WM_USER+10 }
                                                                                        >  3431  enum : uint { TBM_SETSELSTART = WM_USER+11 }
                                                                                        >  3432  enum : uint { TBM_SETSELEND = WM_USER+12 }
                                                                                        >  3433  enum : uint { TBM_GETPTICS = WM_USER+14 }
                                                                                        >  3434  enum : uint { TBM_GETTICPOS = WM_USER+15 }
                                                                                        >  3435  enum : uint { TBM_GETNUMTICS = WM_USER+16 }
                                                                                        >  3436  enum : uint { TBM_GETSELSTART = WM_USER+17 }
                                                                                        >  3437  enum : uint { TBM_GETSELEND = WM_USER+18 }
                                                                                        >  3438  enum : uint { TBM_CLEARSEL = WM_USER+19 }
                                                                                        >  3439  enum : uint { TBM_SETTICFREQ = WM_USER+20 }
                                                                                        >  3440  enum : uint { TBM_SETPAGESIZE = WM_USER+21 }
                                                                                        >  3441  enum : uint { TBM_GETPAGESIZE = WM_USER+22 }
                                                                                        >  3442  enum : uint { TBM_SETLINESIZE = WM_USER+23 }
                                                                                        >  3443  enum : uint { TBM_GETLINESIZE = WM_USER+24 }
                                                                                        >  3444  enum : uint { TBM_GETTHUMBRECT = WM_USER+25 }
                                                                                        >  3445  enum : uint { TBM_GETCHANNELRECT = WM_USER+26 }
                                                                                        >  3446  enum : uint { TBM_SETTHUMBLENGTH = WM_USER+27 }
                                                                                        >  3447  enum : uint { TBM_GETTHUMBLENGTH = WM_USER+28 }
                                                                                        >  3448  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3449  enum : uint { TBM_SETTOOLTIPS = WM_USER+29 }
                                                                                        >  3450  enum : uint { TBM_GETTOOLTIPS = WM_USER+30 }
                                                                                        >  3451  enum : uint { TBM_SETTIPSIDE = WM_USER+31 }
                                                                                        >  3452  
                                                                                        >  3453  enum : uint { TBTS_TOP = 0 }
                                                                                        >  3454  enum : uint { TBTS_LEFT = 1 }
                                                                                        >  3455  enum : uint { TBTS_BOTTOM = 2 }
                                                                                        >  3456  enum : uint { TBTS_RIGHT = 3 }
                                                                                        >  3457  
                                                                                        >  3458  enum : uint { TBM_SETBUDDY = WM_USER+32 }
                                                                                        >  3459  enum : uint { TBM_GETBUDDY = WM_USER+33 }
                                                                                        >  3460  // #endif
                                                                                        >  3461  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3462  alias CCM_SETUNICODEFORMAT TBM_SETUNICODEFORMAT;
                                                                                        >  3463  alias CCM_GETUNICODEFORMAT TBM_GETUNICODEFORMAT;
                                                                                        >  3464  // #endif
                                                                                        >  3465  
                                                                                        >  3466  enum : uint { TB_LINEUP = 0 }
                                                                                        >  3467  enum : uint { TB_LINEDOWN = 1 }
                                                                                        >  3468  enum : uint { TB_PAGEUP = 2 }
                                                                                        >  3469  enum : uint { TB_PAGEDOWN = 3 }
                                                                                        >  3470  enum : uint { TB_THUMBPOSITION = 4 }
                                                                                        >  3471  enum : uint { TB_THUMBTRACK = 5 }
                                                                                        >  3472  enum : uint { TB_TOP = 6 }
                                                                                        >  3473  enum : uint { TB_BOTTOM = 7 }
                                                                                        >  3474  enum : uint { TB_ENDTRACK = 8 }
                                                                                        >  3475  
                                                                                        >  3476  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3477  
                                                                                        >  3478  enum : uint { TBCD_TICS = 0x0001 }
                                                                                        >  3479  enum : uint { TBCD_THUMB = 0x0002 }
                                                                                        >  3480  enum : uint { TBCD_CHANNEL = 0x0003 }
                                                                                        >  3481  // #endif
                                                                                        >  3482  
                                                                                        >  3483  // #endif // trackbar
                                                                                        >  3484  
                                                                                        >  3485  // #ifndef NODRAGLIST
                                                                                        >  3486  
                                                                                        >  3487  struct tagDRAGLISTINFO {
                                                                                        >  3488    UINT uNotification;
                                                                                        >  3489    HWND hWnd;
                                                                                        >  3490    POINT ptCursor;
                                                                                        >  3491  }
                                                                                        >  3492  alias tagDRAGLISTINFO DRAGLISTINFO;
                                                                                        >  3493  alias tagDRAGLISTINFO* LPDRAGLISTINFO;
                                                                                        >  3494  
                                                                                        >  3495  enum : uint { DL_BEGINDRAG = WM_USER+133 }
                                                                                        >  3496  enum : uint { DL_DRAGGING = WM_USER+134 }
                                                                                        >  3497  enum : uint { DL_DROPPED = WM_USER+135 }
                                                                                        >  3498  enum : uint { DL_CANCELDRAG = WM_USER+136 }
                                                                                        >  3499  
                                                                                        >  3500  enum : uint { DL_CURSORSET = 0 }
                                                                                        >  3501  enum : uint { DL_STOPCURSOR = 1 }
                                                                                        >  3502  enum : uint { DL_COPYCURSOR = 2 }
                                                                                        >  3503  enum : uint { DL_MOVECURSOR = 3 }
                                                                                        >  3504  
                                                                                        >  3505  const TCHAR[] DRAGLISTMSGSTRING = "commctrl_DragListMsg";
                                                                                        >  3506  
                                                                                        >  3507  extern(Windows) export BOOL MakeDragList(HWND hLB);
                                                                                        >  3508  extern(Windows) export void DrawInsert(HWND handParent, HWND hLB, int nItem);
                                                                                        >  3509  
                                                                                        >  3510  extern(Windows) export int LBItemFromPt(HWND hLB, POINT pt, BOOL bAutoScroll);
                                                                                        >  3511  
                                                                                        >  3512  // #endif
                                                                                        >  3513  
                                                                                        >  3514  // #ifndef NOUPDOWN
                                                                                        >  3515  
                                                                                        >  3516  // #ifdef _WIN32
                                                                                        >  3517  
                                                                                        >  3518  const char[] UPDOWN_CLASSA = "msctls_updown32";
                                                                                        >  3519  const wchar[] UPDOWN_CLASSW = "msctls_updown32";
                                                                                        >  3520  
                                                                                        >  3521  // #ifdef UNICODE
                                                                                        >  3522  // #...
                                                                                        >  3523  // #else
                                                                                        >  3524  alias UPDOWN_CLASSA UPDOWN_CLASS;
                                                                                        >  3525  // #endif
                                                                                        >  3526  
                                                                                        >  3527  // #else
                                                                                        >  3528  // #...
                                                                                        >  3529  // #endif
                                                                                        >  3530  
                                                                                        >  3531  struct _UDACCEL {
                                                                                        >  3532    UINT nSec;
                                                                                        >  3533    UINT nInc;
                                                                                        >  3534  }
                                                                                        >  3535  alias _UDACCEL UDACCEL;
                                                                                        >  3536  alias _UDACCEL* LPUDACCEL;
                                                                                        >  3537  
                                                                                        >  3538  enum : uint { UD_MAXVAL = 0x7fff }
                                                                                        >  3539  enum : uint { UD_MINVAL = -UD_MAXVAL }
                                                                                        >  3540  
                                                                                        >  3541  enum : uint { UDS_WRAP = 0x0001 }
                                                                                        >  3542  enum : uint { UDS_SETBUDDYINT = 0x0002 }
                                                                                        >  3543  enum : uint { UDS_ALIGNRIGHT = 0x0004 }
                                                                                        >  3544  enum : uint { UDS_ALIGNLEFT = 0x0008 }
                                                                                        >  3545  enum : uint { UDS_AUTOBUDDY = 0x0010 }
                                                                                        >  3546  enum : uint { UDS_ARROWKEYS = 0x0020 }
                                                                                        >  3547  enum : uint { UDS_HORZ = 0x0040 }
                                                                                        >  3548  enum : uint { UDS_NOTHOUSANDS = 0x0080 }
                                                                                        >  3549  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3550  enum : uint { UDS_HOTTRACK = 0x0100 }
                                                                                        >  3551  // #endif
                                                                                        >  3552  
                                                                                        >  3553  enum : uint { UDM_SETRANGE = WM_USER+101 }
                                                                                        >  3554  enum : uint { UDM_GETRANGE = WM_USER+102 }
                                                                                        >  3555  enum : uint { UDM_SETPOS = WM_USER+103 }
                                                                                        >  3556  enum : uint { UDM_GETPOS = WM_USER+104 }
                                                                                        >  3557  enum : uint { UDM_SETBUDDY = WM_USER+105 }
                                                                                        >  3558  enum : uint { UDM_GETBUDDY = WM_USER+106 }
                                                                                        >  3559  enum : uint { UDM_SETACCEL = WM_USER+107 }
                                                                                        >  3560  enum : uint { UDM_GETACCEL = WM_USER+108 }
                                                                                        >  3561  enum : uint { UDM_SETBASE = WM_USER+109 }
                                                                                        >  3562  enum : uint { UDM_GETBASE = WM_USER+110 }
                                                                                        >  3563  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3564  enum : uint { UDM_SETRANGE32 = WM_USER+111 }
                                                                                        >  3565  enum : uint { UDM_GETRANGE32 = WM_USER+112 }
                                                                                        >  3566  alias CCM_SETUNICODEFORMAT UDM_SETUNICODEFORMAT;
                                                                                        >  3567  alias CCM_GETUNICODEFORMAT UDM_GETUNICODEFORMAT;
                                                                                        >  3568  // #endif
                                                                                        >  3569  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  3570  enum : uint { UDM_SETPOS32 = WM_USER+113 }
                                                                                        >  3571  enum : uint { UDM_GETPOS32 = WM_USER+114 }
                                                                                        >  3572  // #endif
                                                                                        >  3573  
                                                                                        >  3574  extern(Windows) export HWND CreateUpDownControl(DWORD dwStyle, int x, int y, int
                                                                                        >  3575    HWND hParent, int nID, HINSTANCE hInst,
                                                                                        >  3576    HWND hBuddy,
                                                                                        >  3577    int nUpper, int nLower, int nPos);
                                                                                        >  3578  
                                                                                        >  3579  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3580  alias NMUPDOWN NM_UPDOWN;
                                                                                        >  3581  alias LPNMUPDOWN LPNM_UPDOWN;
                                                                                        >  3582  // #else
                                                                                        >  3583  // #...
                                                                                        >  3584  // #...
                                                                                        >  3585  // #endif
                                                                                        >  3586  
                                                                                        >  3587  struct _NM_UPDOWN {
                                                                                        >  3588    NMHDR hdr;
                                                                                        >  3589    int iPos;
                                                                                        >  3590    int iDelta;
                                                                                        >  3591  }
                                                                                        >  3592  alias _NM_UPDOWN NMUPDOWN;
                                                                                        >  3593  alias _NM_UPDOWN* LPNMUPDOWN;
                                                                                        >  3594  
                                                                                        >  3595  enum : uint { UDN_DELTAPOS = UDN_FIRST - 1 }
                                                                                        >  3596  
                                                                                        >  3597  // #endif  // NOUPDOWN
                                                                                        >  3598  
                                                                                        >  3599  // #ifndef NOPROGRESS
                                                                                        >  3600  
                                                                                        >  3601  // #ifdef _WIN32
                                                                                        >  3602  
                                                                                        >  3603  const char[] PROGRESS_CLASSA = "msctls_progress32";
                                                                                        >  3604  const wchar[] PROGRESS_CLASSW = "msctls_progress32";
                                                                                        >  3605  
                                                                                        >  3606  // #ifdef UNICODE
                                                                                        >  3607  // #...
                                                                                        >  3608  // #else
                                                                                        >  3609  alias PROGRESS_CLASSA PROGRESS_CLASS;
                                                                                        >  3610  // #endif
                                                                                        >  3611  
                                                                                        >  3612  // #else
                                                                                        >  3613  // #...
                                                                                        >  3614  // #endif
                                                                                        >  3615  
                                                                                        >  3616  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3617  enum : uint { PBS_SMOOTH = 0x01 }
                                                                                        >  3618  enum : uint { PBS_VERTICAL = 0x04 }
                                                                                        >  3619  // #endif
                                                                                        >  3620  
                                                                                        >  3621  enum : uint { PBM_SETRANGE = WM_USER+1 }
                                                                                        >  3622  enum : uint { PBM_SETPOS = WM_USER+2 }
                                                                                        >  3623  enum : uint { PBM_DELTAPOS = WM_USER+3 }
                                                                                        >  3624  enum : uint { PBM_SETSTEP = WM_USER+4 }
                                                                                        >  3625  enum : uint { PBM_STEPIT = WM_USER+5 }
                                                                                        >  3626  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3627  enum : uint { PBM_SETRANGE32 = WM_USER+6 }
                                                                                        >  3628  struct _7 {
                                                                                        >  3629    int iLow;
                                                                                        >  3630    int iHigh;
                                                                                        >  3631  }
                                                                                        >  3632  alias _7 PBRANGE;
                                                                                        >  3633  alias _7* PPBRANGE;
                                                                                        >  3634  
                                                                                        >  3635  enum : uint { PBM_GETRANGE = WM_USER+7 }
                                                                                        >  3636  enum : uint { PBM_GETPOS = WM_USER+8 }
                                                                                        >  3637  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3638  enum : uint { PBM_SETBARCOLOR = WM_USER+9 }
                                                                                        >  3639  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  3640  alias CCM_SETBKCOLOR PBM_SETBKCOLOR;
                                                                                        >  3641  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  3642  
                                                                                        >  3643  // #endif  // NOPROGRESS
                                                                                        >  3644  
                                                                                        >  3645  // #ifndef NOHOTKEY
                                                                                        >  3646  
                                                                                        >  3647  enum : uint { HOTKEYF_SHIFT = 0x01 }
                                                                                        >  3648  enum : uint { HOTKEYF_CONTROL = 0x02 }
                                                                                        >  3649  enum : uint { HOTKEYF_ALT = 0x04 }
                                                                                        >  3650  // #ifdef _MAC
                                                                                        >  3651  // #...
                                                                                        >  3652  // #else
                                                                                        >  3653  enum : uint { HOTKEYF_EXT = 0x08 }
                                                                                        >  3654  // #endif
                                                                                        >  3655  
                                                                                        >  3656  enum : uint { HKCOMB_NONE = 0x0001 }
                                                                                        >  3657  enum : uint { HKCOMB_S = 0x0002 }
                                                                                        >  3658  enum : uint { HKCOMB_C = 0x0004 }
                                                                                        >  3659  enum : uint { HKCOMB_A = 0x0008 }
                                                                                        >  3660  enum : uint { HKCOMB_SC = 0x0010 }
                                                                                        >  3661  enum : uint { HKCOMB_SA = 0x0020 }
                                                                                        >  3662  enum : uint { HKCOMB_CA = 0x0040 }
                                                                                        >  3663  enum : uint { HKCOMB_SCA = 0x0080 }
                                                                                        >  3664  
                                                                                        >  3665  enum : uint { HKM_SETHOTKEY = WM_USER+1 }
                                                                                        >  3666  enum : uint { HKM_GETHOTKEY = WM_USER+2 }
                                                                                        >  3667  enum : uint { HKM_SETRULES = WM_USER+3 }
                                                                                        >  3668  
                                                                                        >  3669  // #ifdef _WIN32
                                                                                        >  3670  
                                                                                        >  3671  const char[] HOTKEY_CLASSA = "msctls_hotkey32";
                                                                                        >  3672  const wchar[] HOTKEY_CLASSW = "msctls_hotkey32";
                                                                                        >  3673  
                                                                                        >  3674  // #ifdef UNICODE
                                                                                        >  3675  // #...
                                                                                        >  3676  // #else
                                                                                        >  3677  alias HOTKEY_CLASSA HOTKEY_CLASS;
                                                                                        >  3678  // #endif
                                                                                        >  3679  
                                                                                        >  3680  // #else
                                                                                        >  3681  // #...
                                                                                        >  3682  // #endif
                                                                                        >  3683  
                                                                                        >  3684  // #endif  // NOHOTKEY
                                                                                        >  3685  
                                                                                        >  3686  enum : uint { CCS_TOP = 0x00000001 }
                                                                                        >  3687  enum : uint { CCS_NOMOVEY = 0x00000002 }
                                                                                        >  3688  enum : uint { CCS_BOTTOM = 0x00000003 }
                                                                                        >  3689  enum : uint { CCS_NORESIZE = 0x00000004 }
                                                                                        >  3690  enum : uint { CCS_NOPARENTALIGN = 0x00000008 }
                                                                                        >  3691  enum : uint { CCS_ADJUSTABLE = 0x00000020 }
                                                                                        >  3692  enum : uint { CCS_NODIVIDER = 0x00000040 }
                                                                                        >  3693  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3694  enum : uint { CCS_VERT = 0x00000080 }
                                                                                        >  3695  enum : uint { CCS_LEFT = CCS_VERT | CCS_TOP }
                                                                                        >  3696  enum : uint { CCS_RIGHT = CCS_VERT | CCS_BOTTOM }
                                                                                        >  3697  enum : uint { CCS_NOMOVEX = CCS_VERT | CCS_NOMOVEY }
                                                                                        >  3698  // #endif
                                                                                        >  3699  
                                                                                        >  3700  // #ifndef NOLISTVIEW
                                                                                        >  3701  
                                                                                        >  3702  // #ifdef _WIN32
                                                                                        >  3703  
                                                                                        >  3704  const char[] WC_LISTVIEWA = "SysListView32";
                                                                                        >  3705  const wchar[] WC_LISTVIEWW = "SysListView32";
                                                                                        >  3706  
                                                                                        >  3707  // #ifdef UNICODE
                                                                                        >  3708  // #...
                                                                                        >  3709  // #else
                                                                                        >  3710  alias WC_LISTVIEWA WC_LISTVIEW;
                                                                                        >  3711  // #endif
                                                                                        >  3712  
                                                                                        >  3713  // #else
                                                                                        >  3714  // #...
                                                                                        >  3715  // #endif
                                                                                        >  3716  
                                                                                        >  3717  enum : uint { LVS_ICON = 0x0000 }
                                                                                        >  3718  enum : uint { LVS_REPORT = 0x0001 }
                                                                                        >  3719  enum : uint { LVS_SMALLICON = 0x0002 }
                                                                                        >  3720  enum : uint { LVS_LIST = 0x0003 }
                                                                                        >  3721  enum : uint { LVS_TYPEMASK = 0x0003 }
                                                                                        >  3722  enum : uint { LVS_SINGLESEL = 0x0004 }
                                                                                        >  3723  enum : uint { LVS_SHOWSELALWAYS = 0x0008 }
                                                                                        >  3724  enum : uint { LVS_SORTASCENDING = 0x0010 }
                                                                                        >  3725  enum : uint { LVS_SORTDESCENDING = 0x0020 }
                                                                                        >  3726  enum : uint { LVS_SHAREIMAGELISTS = 0x0040 }
                                                                                        >  3727  enum : uint { LVS_NOLABELWRAP = 0x0080 }
                                                                                        >  3728  enum : uint { LVS_AUTOARRANGE = 0x0100 }
                                                                                        >  3729  enum : uint { LVS_EDITLABELS = 0x0200 }
                                                                                        >  3730  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3731  enum : uint { LVS_OWNERDATA = 0x1000 }
                                                                                        >  3732  // #endif
                                                                                        >  3733  enum : uint { LVS_NOSCROLL = 0x2000 }
                                                                                        >  3734  
                                                                                        >  3735  enum : uint { LVS_TYPESTYLEMASK = 0xfc00 }
                                                                                        >  3736  
                                                                                        >  3737  enum : uint { LVS_ALIGNTOP = 0x0000 }
                                                                                        >  3738  enum : uint { LVS_ALIGNLEFT = 0x0800 }
                                                                                        >  3739  enum : uint { LVS_ALIGNMASK = 0x0c00 }
                                                                                        >  3740  
                                                                                        >  3741  enum : uint { LVS_OWNERDRAWFIXED = 0x0400 }
                                                                                        >  3742  enum : uint { LVS_NOCOLUMNHEADER = 0x4000 }
                                                                                        >  3743  enum : uint { LVS_NOSORTHEADER = 0x8000 }
                                                                                        >  3744  
                                                                                        >  3745  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  3746  alias CCM_SETUNICODEFORMAT LVM_SETUNICODEFORMAT;
                                                                                        >  3747  // #define ListView_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), LVM_SE
                                                                                        >  3748  
                                                                                        >  3749  alias CCM_GETUNICODEFORMAT LVM_GETUNICODEFORMAT;
                                                                                        >  3750  // #define ListView_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), LVM_GETUNICODEFO
                                                                                        >  3751  // #endif
                                                                                        >  3752  
                                                                                        >  3753  enum : uint { LVM_GETBKCOLOR = LVM_FIRST + 0 }
                                                                                        >  3754  // #define ListView_GetBkColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETBKCOLOR, 0,
                                                                                        >  3755  
                                                                                        >  3756  enum : uint { LVM_SETBKCOLOR = LVM_FIRST + 1 }
                                                                                        >  3757  // #define ListView_SetBkColor(hwnd, clrBk) (BOOL)SNDMSG((hwnd), LVM_SETBKCOLOR,
                                                                                        >  3758  
                                                                                        >  3759  enum : uint { LVM_GETIMAGELIST = LVM_FIRST + 2 }
                                                                                        >  3760  // #define ListView_GetImageList(hwnd, iImageList) (HIMAGELIST)SNDMSG((hwnd), LV
                                                                                        >  3761  
                                                                                        >  3762  enum : uint { LVSIL_NORMAL = 0 }
                                                                                        >  3763  enum : uint { LVSIL_SMALL = 1 }
                                                                                        >  3764  enum : uint { LVSIL_STATE = 2 }
                                                                                        >  3765  
                                                                                        >  3766  enum : uint { LVM_SETIMAGELIST = LVM_FIRST + 3 }
                                                                                        >  3767  // #define ListView_SetImageList(hwnd, himl, iImageList) (HIMAGELIST)SNDMSG((hwn
                                                                                        >  3768  
                                                                                        >  3769  enum : uint { LVM_GETITEMCOUNT = LVM_FIRST + 4 }
                                                                                        >  3770  // #define ListView_GetItemCount(hwnd) (int)SNDMSG((hwnd), LVM_GETITEMCOUNT, 0, 
                                                                                        >  3771  
                                                                                        >  3772  enum : uint { LVIF_TEXT = 0x0001 }
                                                                                        >  3773  enum : uint { LVIF_IMAGE = 0x0002 }
                                                                                        >  3774  enum : uint { LVIF_PARAM = 0x0004 }
                                                                                        >  3775  enum : uint { LVIF_STATE = 0x0008 }
                                                                                        >  3776  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3777  enum : uint { LVIF_INDENT = 0x0010 }
                                                                                        >  3778  enum : uint { LVIF_NORECOMPUTE = 0x0800 }
                                                                                        >  3779  // #endif
                                                                                        >  3780  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  3781  enum : uint { LVIF_GROUPID = 0x0100 }
                                                                                        >  3782  enum : uint { LVIF_COLUMNS = 0x0200 }
                                                                                        >  3783  // #endif
                                                                                        >  3784  
                                                                                        >  3785  enum : uint { LVIS_FOCUSED = 0x0001 }
                                                                                        >  3786  enum : uint { LVIS_SELECTED = 0x0002 }
                                                                                        >  3787  enum : uint { LVIS_CUT = 0x0004 }
                                                                                        >  3788  enum : uint { LVIS_DROPHILITED = 0x0008 }
                                                                                        >  3789  enum : uint { LVIS_GLOW = 0x0010 }
                                                                                        >  3790  enum : uint { LVIS_ACTIVATING = 0x0020 }
                                                                                        >  3791  
                                                                                        >  3792  enum : uint { LVIS_OVERLAYMASK = 0x0F00 }
                                                                                        >  3793  enum : uint { LVIS_STATEIMAGEMASK = 0xF000 }
                                                                                        >  3794  
                                                                                        >  3795  uint INDEXTOSTATEIMAGEMASK(uint i){ return i << 12; }
                                                                                        >  3796  
                                                                                        >  3797  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3798  enum { I_INDENTCALLBACK = -1 }
                                                                                        >  3799  alias LVITEMA LV_ITEMA;
                                                                                        >  3800  alias LVITEMW LV_ITEMW;
                                                                                        >  3801  // #else
                                                                                        >  3802  // #...
                                                                                        >  3803  // #...
                                                                                        >  3804  // #...
                                                                                        >  3805  // #...
                                                                                        >  3806  // #endif
                                                                                        >  3807  
                                                                                        >  3808  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  3809  enum { I_GROUPIDCALLBACK = -1 }
                                                                                        >  3810  enum { I_GROUPIDNONE = -2 }
                                                                                        >  3811  // #endif
                                                                                        >  3812  alias LVITEM LV_ITEM;
                                                                                        >  3813  
                                                                                        >  3814  // #define LVITEMA_V1_SIZE CCSIZEOF_STRUCT(LVITEMA, lParam)
                                                                                        >  3815  // #define LVITEMW_V1_SIZE CCSIZEOF_STRUCT(LVITEMW, lParam)
                                                                                        >  3816  
                                                                                        >  3817  struct tagLVITEMA {
                                                                                        >  3818    UINT mask;
                                                                                        >  3819    int iItem;
                                                                                        >  3820    int iSubItem;
                                                                                        >  3821    UINT state;
                                                                                        >  3822    UINT stateMask;
                                                                                        >  3823    LPSTR pszText;
                                                                                        >  3824    int cchTextMax;
                                                                                        >  3825    int iImage;
                                                                                        >  3826    LPARAM lParam;
                                                                                        >  3827  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3828    int iIndent;
                                                                                        >  3829  // #endif
                                                                                        >  3830  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  3831    int iGroupId;
                                                                                        >  3832    UINT cColumns;
                                                                                        >  3833    PUINT puColumns;
                                                                                        >  3834  // #endif
                                                                                        >  3835  }
                                                                                        >  3836  alias tagLVITEMA LVITEMA;
                                                                                        >  3837  alias tagLVITEMA* LPLVITEMA;
                                                                                        >  3838  
                                                                                        >  3839  struct tagLVITEMW {
                                                                                        >  3840    UINT mask;
                                                                                        >  3841    int iItem;
                                                                                        >  3842    int iSubItem;
                                                                                        >  3843    UINT state;
                                                                                        >  3844    UINT stateMask;
                                                                                        >  3845    LPWSTR pszText;
                                                                                        >  3846    int cchTextMax;
                                                                                        >  3847    int iImage;
                                                                                        >  3848    LPARAM lParam;
                                                                                        >  3849  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3850    int iIndent;
                                                                                        >  3851  // #endif
                                                                                        >  3852  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  3853    int iGroupId;
                                                                                        >  3854    UINT cColumns;
                                                                                        >  3855    PUINT puColumns;
                                                                                        >  3856  // #endif
                                                                                        >  3857  }
                                                                                        >  3858  alias tagLVITEMW LVITEMW;
                                                                                        >  3859  alias tagLVITEMW* LPLVITEMW;
                                                                                        >  3860  
                                                                                        >  3861  // #ifdef UNICODE
                                                                                        >  3862  // #...
                                                                                        >  3863  // #...
                                                                                        >  3864  // #...
                                                                                        >  3865  // #else
                                                                                        >  3866  alias LVITEMA LVITEM;
                                                                                        >  3867  alias LPLVITEMA LPLVITEM;
                                                                                        >  3868  // #define LVITEM_V1_SIZE LVITEMA_V1_SIZE
                                                                                        >  3869  // #endif
                                                                                        >  3870  
                                                                                        >  3871  const LPWSTR LPSTR_TEXTCALLBACKW = cast(LPWSTR)-1;
                                                                                        >  3872  const LPSTR LPSTR_TEXTCALLBACKA = cast(LPSTR)-1;
                                                                                        >  3873  // #ifdef UNICODE
                                                                                        >  3874  // #...
                                                                                        >  3875  // #else
                                                                                        >  3876  alias LPSTR_TEXTCALLBACKA LPSTR_TEXTCALLBACK;
                                                                                        >  3877  // #endif
                                                                                        >  3878  
                                                                                        >  3879  enum { I_IMAGECALLBACK = -1 }
                                                                                        >  3880  // #if (_WIN32_IE >= 0x0501)
                                                                                        >  3881  enum { I_IMAGENONE = -2 }
                                                                                        >  3882  // #endif  // 0x0501
                                                                                        >  3883  
                                                                                        >  3884  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  3885  
                                                                                        >  3886  enum : uint { I_COLUMNSCALLBACK = cast(UINT)-1 }
                                                                                        >  3887  // #endif
                                                                                        >  3888  
                                                                                        >  3889  enum : uint { LVM_GETITEMA = LVM_FIRST + 5 }
                                                                                        >  3890  enum : uint { LVM_GETITEMW = LVM_FIRST + 75 }
                                                                                        >  3891  // #ifdef UNICODE
                                                                                        >  3892  // #...
                                                                                        >  3893  // #else
                                                                                        >  3894  alias LVM_GETITEMA LVM_GETITEM;
                                                                                        >  3895  // #endif
                                                                                        >  3896  
                                                                                        >  3897  // #define ListView_GetItem(hwnd, pitem) (BOOL)SNDMSG((hwnd), LVM_GETITEM, 0, (L
                                                                                        >  3898  
                                                                                        >  3899  enum : uint { LVM_SETITEMA = LVM_FIRST + 6 }
                                                                                        >  3900  enum : uint { LVM_SETITEMW = LVM_FIRST + 76 }
                                                                                        >  3901  // #ifdef UNICODE
                                                                                        >  3902  // #...
                                                                                        >  3903  // #else
                                                                                        >  3904  alias LVM_SETITEMA LVM_SETITEM;
                                                                                        >  3905  // #endif
                                                                                        >  3906  
                                                                                        >  3907  // #define ListView_SetItem(hwnd, pitem) (BOOL)SNDMSG((hwnd), LVM_SETITEM, 0, (L
                                                                                        >  3908  
                                                                                        >  3909  enum : uint { LVM_INSERTITEMA = LVM_FIRST + 7 }
                                                                                        >  3910  enum : uint { LVM_INSERTITEMW = LVM_FIRST + 77 }
                                                                                        >  3911  // #ifdef UNICODE
                                                                                        >  3912  // #...
                                                                                        >  3913  // #else
                                                                                        >  3914  alias LVM_INSERTITEMA LVM_INSERTITEM;
                                                                                        >  3915  // #endif
                                                                                        >  3916  // #define ListView_InsertItem(hwnd, pitem) (int)SNDMSG((hwnd), LVM_INSERTITEM, 
                                                                                        >  3917  
                                                                                        >  3918  enum : uint { LVM_DELETEITEM = LVM_FIRST + 8 }
                                                                                        >  3919  // #define ListView_DeleteItem(hwnd, i) (BOOL)SNDMSG((hwnd), LVM_DELETEITEM, (WP
                                                                                        >  3920  
                                                                                        >  3921  enum : uint { LVM_DELETEALLITEMS = LVM_FIRST + 9 }
                                                                                        >  3922  // #define ListView_DeleteAllItems(hwnd) (BOOL)SNDMSG((hwnd), LVM_DELETEALLITEMS
                                                                                        >  3923  
                                                                                        >  3924  enum : uint { LVM_GETCALLBACKMASK = LVM_FIRST + 10 }
                                                                                        >  3925  // #define ListView_GetCallbackMask(hwnd) (BOOL)SNDMSG((hwnd), LVM_GETCALLBACKMA
                                                                                        >  3926  
                                                                                        >  3927  enum : uint { LVM_SETCALLBACKMASK = LVM_FIRST + 11 }
                                                                                        >  3928  // #define ListView_SetCallbackMask(hwnd, mask) (BOOL)SNDMSG((hwnd), LVM_SETCALL
                                                                                        >  3929  
                                                                                        >  3930  enum : uint { LVNI_ALL = 0x0000 }
                                                                                        >  3931  enum : uint { LVNI_FOCUSED = 0x0001 }
                                                                                        >  3932  enum : uint { LVNI_SELECTED = 0x0002 }
                                                                                        >  3933  enum : uint { LVNI_CUT = 0x0004 }
                                                                                        >  3934  enum : uint { LVNI_DROPHILITED = 0x0008 }
                                                                                        >  3935  
                                                                                        >  3936  enum : uint { LVNI_ABOVE = 0x0100 }
                                                                                        >  3937  enum : uint { LVNI_BELOW = 0x0200 }
                                                                                        >  3938  enum : uint { LVNI_TOLEFT = 0x0400 }
                                                                                        >  3939  enum : uint { LVNI_TORIGHT = 0x0800 }
                                                                                        >  3940  
                                                                                        >  3941  enum : uint { LVM_GETNEXTITEM = LVM_FIRST + 12 }
                                                                                        >  3942  // #define ListView_GetNextItem(hwnd, i, flags) (int)SNDMSG((hwnd), LVM_GETNEXTI
                                                                                        >  3943  
                                                                                        >  3944  enum : uint { LVFI_PARAM = 0x0001 }
                                                                                        >  3945  enum : uint { LVFI_STRING = 0x0002 }
                                                                                        >  3946  enum : uint { LVFI_PARTIAL = 0x0008 }
                                                                                        >  3947  enum : uint { LVFI_WRAP = 0x0020 }
                                                                                        >  3948  enum : uint { LVFI_NEARESTXY = 0x0040 }
                                                                                        >  3949  
                                                                                        >  3950  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  3951  alias LVFINDINFOA LV_FINDINFOA;
                                                                                        >  3952  alias LVFINDINFOW LV_FINDINFOW;
                                                                                        >  3953  // #else
                                                                                        >  3954  // #...
                                                                                        >  3955  // #...
                                                                                        >  3956  // #...
                                                                                        >  3957  // #...
                                                                                        >  3958  // #endif
                                                                                        >  3959  
                                                                                        >  3960  alias LVFINDINFO LV_FINDINFO;
                                                                                        >  3961  
                                                                                        >  3962  struct tagLVFINDINFOA {
                                                                                        >  3963    UINT flags;
                                                                                        >  3964    LPCSTR psz;
                                                                                        >  3965    LPARAM lParam;
                                                                                        >  3966    POINT pt;
                                                                                        >  3967    UINT vkDirection;
                                                                                        >  3968  }
                                                                                        >  3969  alias tagLVFINDINFOA LVFINDINFOA;
                                                                                        >  3970  alias tagLVFINDINFOA* LPFINDINFOA;
                                                                                        >  3971  
                                                                                        >  3972  struct tagLVFINDINFOW {
                                                                                        >  3973    UINT flags;
                                                                                        >  3974    LPCWSTR psz;
                                                                                        >  3975    LPARAM lParam;
                                                                                        >  3976    POINT pt;
                                                                                        >  3977    UINT vkDirection;
                                                                                        >  3978  }
                                                                                        >  3979  alias tagLVFINDINFOW LVFINDINFOW;
                                                                                        >  3980  alias tagLVFINDINFOW* LPFINDINFOW;
                                                                                        >  3981  
                                                                                        >  3982  // #ifdef UNICODE
                                                                                        >  3983  // #...
                                                                                        >  3984  // #else
                                                                                        >  3985  alias LVFINDINFOA LVFINDINFO;
                                                                                        >  3986  // #endif
                                                                                        >  3987  
                                                                                        >  3988  enum : uint { LVM_FINDITEMA = LVM_FIRST + 13 }
                                                                                        >  3989  enum : uint { LVM_FINDITEMW = LVM_FIRST + 83 }
                                                                                        >  3990  // #ifdef UNICODE
                                                                                        >  3991  // #...
                                                                                        >  3992  // #else
                                                                                        >  3993  alias LVM_FINDITEMA LVM_FINDITEM;
                                                                                        >  3994  // #endif
                                                                                        >  3995  
                                                                                        >  3996  // #define ListView_FindItem(hwnd, iStart, plvfi) (int)SNDMSG((hwnd), LVM_FINDIT
                                                                                        >  3997  
                                                                                        >  3998  enum : uint { LVIR_BOUNDS = 0 }
                                                                                        >  3999  enum : uint { LVIR_ICON = 1 }
                                                                                        >  4000  enum : uint { LVIR_LABEL = 2 }
                                                                                        >  4001  enum : uint { LVIR_SELECTBOUNDS = 3 }
                                                                                        >  4002  
                                                                                        >  4003  enum : uint { LVM_GETITEMRECT = LVM_FIRST + 14 }
                                                                                        >  4004  // #define ListView_GetItemRect(hwnd, i, prc, code) (BOOL)SNDMSG((hwnd), LVM_GET
                                                                                        >  4005  
                                                                                        >  4006  enum : uint { LVM_SETITEMPOSITION = LVM_FIRST + 15 }
                                                                                        >  4007  // #define ListView_SetItemPosition(hwndLV, i, x, y) (BOOL)SNDMSG((hwndLV), LVM_
                                                                                        >  4008  
                                                                                        >  4009  enum : uint { LVM_GETITEMPOSITION = LVM_FIRST + 16 }
                                                                                        >  4010  // #define ListView_GetItemPosition(hwndLV, i, ppt) (BOOL)SNDMSG((hwndLV), LVM_G
                                                                                        >  4011  
                                                                                        >  4012  enum : uint { LVM_GETSTRINGWIDTHA = LVM_FIRST + 17 }
                                                                                        >  4013  enum : uint { LVM_GETSTRINGWIDTHW = LVM_FIRST + 87 }
                                                                                        >  4014  // #ifdef UNICODE
                                                                                        >  4015  // #...
                                                                                        >  4016  // #else
                                                                                        >  4017  alias LVM_GETSTRINGWIDTHA LVM_GETSTRINGWIDTH;
                                                                                        >  4018  // #endif
                                                                                        >  4019  
                                                                                        >  4020  // #define ListView_GetStringWidth(hwndLV, psz) (int)SNDMSG((hwndLV), LVM_GETSTR
                                                                                        >  4021  
                                                                                        >  4022  enum : uint { LVHT_NOWHERE = 0x0001 }
                                                                                        >  4023  enum : uint { LVHT_ONITEMICON = 0x0002 }
                                                                                        >  4024  enum : uint { LVHT_ONITEMLABEL = 0x0004 }
                                                                                        >  4025  enum : uint { LVHT_ONITEMSTATEICON = 0x0008 }
                                                                                        >  4026  enum : uint { LVHT_ONITEM = LVHT_ONITEMICON | LVHT_ONITEMLABEL | LVHT_ONITEMSTAT
                                                                                        >  4027  
                                                                                        >  4028  enum : uint { LVHT_ABOVE = 0x0008 }
                                                                                        >  4029  enum : uint { LVHT_BELOW = 0x0010 }
                                                                                        >  4030  enum : uint { LVHT_TORIGHT = 0x0020 }
                                                                                        >  4031  enum : uint { LVHT_TOLEFT = 0x0040 }
                                                                                        >  4032  
                                                                                        >  4033  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4034  alias LVHITTESTINFO LV_HITTESTINFO;
                                                                                        >  4035  // #else
                                                                                        >  4036  // #...
                                                                                        >  4037  // #...
                                                                                        >  4038  // #endif
                                                                                        >  4039  
                                                                                        >  4040  // #define LVHITTESTINFO_V1_SIZE CCSIZEOF_STRUCT(LVHITTESTINFO, iItem)
                                                                                        >  4041  
                                                                                        >  4042  struct tagLVHITTESTINFO {
                                                                                        >  4043    POINT pt;
                                                                                        >  4044    UINT flags;
                                                                                        >  4045    int iItem;
                                                                                        >  4046  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4047    int iSubItem;
                                                                                        >  4048  // #endif
                                                                                        >  4049  }
                                                                                        >  4050  alias tagLVHITTESTINFO LVHITTESTINFO;
                                                                                        >  4051  alias tagLVHITTESTINFO* LPLVHITTESTINFO;
                                                                                        >  4052  
                                                                                        >  4053  enum : uint { LVM_HITTEST = LVM_FIRST + 18 }
                                                                                        >  4054  // #define ListView_HitTest(hwndLV, pinfo) (int)SNDMSG((hwndLV), LVM_HITTEST, 0,
                                                                                        >  4055  
                                                                                        >  4056  enum : uint { LVM_ENSUREVISIBLE = LVM_FIRST + 19 }
                                                                                        >  4057  // #define ListView_EnsureVisible(hwndLV, i, fPartialOK) (BOOL)SNDMSG((hwndLV), 
                                                                                        >  4058  
                                                                                        >  4059  enum : uint { LVM_SCROLL = LVM_FIRST + 20 }
                                                                                        >  4060  // #define ListView_Scroll(hwndLV, dx, dy) (BOOL)SNDMSG((hwndLV), LVM_SCROLL, (W
                                                                                        >  4061  
                                                                                        >  4062  enum : uint { LVM_REDRAWITEMS = LVM_FIRST + 21 }
                                                                                        >  4063  // #define ListView_RedrawItems(hwndLV, iFirst, iLast) (BOOL)SNDMSG((hwndLV), LV
                                                                                        >  4064  
                                                                                        >  4065  enum : uint { LVA_DEFAULT = 0x0000 }
                                                                                        >  4066  enum : uint { LVA_ALIGNLEFT = 0x0001 }
                                                                                        >  4067  enum : uint { LVA_ALIGNTOP = 0x0002 }
                                                                                        >  4068  enum : uint { LVA_SNAPTOGRID = 0x0005 }
                                                                                        >  4069  
                                                                                        >  4070  enum : uint { LVM_ARRANGE = LVM_FIRST + 22 }
                                                                                        >  4071  // #define ListView_Arrange(hwndLV, code) (BOOL)SNDMSG((hwndLV), LVM_ARRANGE, (W
                                                                                        >  4072  
                                                                                        >  4073  enum : uint { LVM_EDITLABELA = LVM_FIRST + 23 }
                                                                                        >  4074  enum : uint { LVM_EDITLABELW = LVM_FIRST + 118 }
                                                                                        >  4075  // #ifdef UNICODE
                                                                                        >  4076  // #...
                                                                                        >  4077  // #else
                                                                                        >  4078  alias LVM_EDITLABELA LVM_EDITLABEL;
                                                                                        >  4079  // #endif
                                                                                        >  4080  
                                                                                        >  4081  // #define ListView_EditLabel(hwndLV, i) (HWND)SNDMSG((hwndLV), LVM_EDITLABEL, (
                                                                                        >  4082  
                                                                                        >  4083  enum : uint { LVM_GETEDITCONTROL = LVM_FIRST + 24 }
                                                                                        >  4084  // #define ListView_GetEditControl(hwndLV) (HWND)SNDMSG((hwndLV), LVM_GETEDITCON
                                                                                        >  4085  
                                                                                        >  4086  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4087  alias LVCOLUMNA LV_COLUMNA;
                                                                                        >  4088  alias LVCOLUMNW LV_COLUMNW;
                                                                                        >  4089  // #else
                                                                                        >  4090  // #...
                                                                                        >  4091  // #...
                                                                                        >  4092  // #...
                                                                                        >  4093  // #...
                                                                                        >  4094  // #endif
                                                                                        >  4095  
                                                                                        >  4096  alias LVCOLUMN LV_COLUMN;
                                                                                        >  4097  
                                                                                        >  4098  // #define LVCOLUMNA_V1_SIZE CCSIZEOF_STRUCT(LVCOLUMNA, iSubItem)
                                                                                        >  4099  // #define LVCOLUMNW_V1_SIZE CCSIZEOF_STRUCT(LVCOLUMNW, iSubItem)
                                                                                        >  4100  
                                                                                        >  4101  struct tagLVCOLUMNA {
                                                                                        >  4102    UINT mask;
                                                                                        >  4103    int fmt;
                                                                                        >  4104    int cx;
                                                                                        >  4105    LPSTR pszText;
                                                                                        >  4106    int cchTextMax;
                                                                                        >  4107    int iSubItem;
                                                                                        >  4108  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4109    int iImage;
                                                                                        >  4110    int iOrder;
                                                                                        >  4111  // #endif
                                                                                        >  4112  }
                                                                                        >  4113  alias tagLVCOLUMNA LVCOLUMNA;
                                                                                        >  4114  alias tagLVCOLUMNA* LPLVCOLUMNA;
                                                                                        >  4115  
                                                                                        >  4116  struct tagLVCOLUMNW {
                                                                                        >  4117    UINT mask;
                                                                                        >  4118    int fmt;
                                                                                        >  4119    int cx;
                                                                                        >  4120    LPWSTR pszText;
                                                                                        >  4121    int cchTextMax;
                                                                                        >  4122    int iSubItem;
                                                                                        >  4123  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4124    int iImage;
                                                                                        >  4125    int iOrder;
                                                                                        >  4126  // #endif
                                                                                        >  4127  }
                                                                                        >  4128  alias tagLVCOLUMNW LVCOLUMNW;
                                                                                        >  4129  alias tagLVCOLUMNW* LPLVCOLUMNW;
                                                                                        >  4130  
                                                                                        >  4131  // #ifdef UNICODE
                                                                                        >  4132  // #...
                                                                                        >  4133  // #...
                                                                                        >  4134  // #...
                                                                                        >  4135  // #else
                                                                                        >  4136  alias LVCOLUMNA LVCOLUMN;
                                                                                        >  4137  alias LPLVCOLUMNA LPLVCOLUMN;
                                                                                        >  4138  // #define LVCOLUMN_V1_SIZE LVCOLUMNA_V1_SIZE
                                                                                        >  4139  // #endif
                                                                                        >  4140  
                                                                                        >  4141  enum : uint { LVCF_FMT = 0x0001 }
                                                                                        >  4142  enum : uint { LVCF_WIDTH = 0x0002 }
                                                                                        >  4143  enum : uint { LVCF_TEXT = 0x0004 }
                                                                                        >  4144  enum : uint { LVCF_SUBITEM = 0x0008 }
                                                                                        >  4145  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4146  enum : uint { LVCF_IMAGE = 0x0010 }
                                                                                        >  4147  enum : uint { LVCF_ORDER = 0x0020 }
                                                                                        >  4148  // #endif
                                                                                        >  4149  
                                                                                        >  4150  enum : uint { LVCFMT_LEFT = 0x0000 }
                                                                                        >  4151  enum : uint { LVCFMT_RIGHT = 0x0001 }
                                                                                        >  4152  enum : uint { LVCFMT_CENTER = 0x0002 }
                                                                                        >  4153  enum : uint { LVCFMT_JUSTIFYMASK = 0x0003 }
                                                                                        >  4154  
                                                                                        >  4155  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4156  enum : uint { LVCFMT_IMAGE = 0x0800 }
                                                                                        >  4157  enum : uint { LVCFMT_BITMAP_ON_RIGHT = 0x1000 }
                                                                                        >  4158  enum : uint { LVCFMT_COL_HAS_IMAGES = 0x8000 }
                                                                                        >  4159  // #endif
                                                                                        >  4160  
                                                                                        >  4161  enum : uint { LVM_GETCOLUMNA = LVM_FIRST + 25 }
                                                                                        >  4162  enum : uint { LVM_GETCOLUMNW = LVM_FIRST + 95 }
                                                                                        >  4163  // #ifdef UNICODE
                                                                                        >  4164  // #...
                                                                                        >  4165  // #else
                                                                                        >  4166  alias LVM_GETCOLUMNA LVM_GETCOLUMN;
                                                                                        >  4167  // #endif
                                                                                        >  4168  
                                                                                        >  4169  // #define ListView_GetColumn(hwnd, iCol, pcol) (BOOL)SNDMSG((hwnd), LVM_GETCOLU
                                                                                        >  4170  
                                                                                        >  4171  enum : uint { LVM_SETCOLUMNA = LVM_FIRST + 26 }
                                                                                        >  4172  enum : uint { LVM_SETCOLUMNW = LVM_FIRST + 96 }
                                                                                        >  4173  // #ifdef UNICODE
                                                                                        >  4174  // #...
                                                                                        >  4175  // #else
                                                                                        >  4176  alias LVM_SETCOLUMNA LVM_SETCOLUMN;
                                                                                        >  4177  // #endif
                                                                                        >  4178  
                                                                                        >  4179  // #define ListView_SetColumn(hwnd, iCol, pcol) (BOOL)SNDMSG((hwnd), LVM_SETCOLU
                                                                                        >  4180  
                                                                                        >  4181  enum : uint { LVM_INSERTCOLUMNA = LVM_FIRST + 27 }
                                                                                        >  4182  enum : uint { LVM_INSERTCOLUMNW = LVM_FIRST + 97 }
                                                                                        >  4183  // #ifdef UNICODE
                                                                                        >  4184  // #...
                                                                                        >  4185  // #else
                                                                                        >  4186  alias LVM_INSERTCOLUMNA LVM_INSERTCOLUMN;
                                                                                        >  4187  // #endif
                                                                                        >  4188  
                                                                                        >  4189  // #define ListView_InsertColumn(hwnd, iCol, pcol) (int)SNDMSG((hwnd), LVM_INSER
                                                                                        >  4190  
                                                                                        >  4191  enum : uint { LVM_DELETECOLUMN = LVM_FIRST + 28 }
                                                                                        >  4192  // #define ListView_DeleteColumn(hwnd, iCol) (BOOL)SNDMSG((hwnd), LVM_DELETECOLU
                                                                                        >  4193  
                                                                                        >  4194  enum : uint { LVM_GETCOLUMNWIDTH = LVM_FIRST + 29 }
                                                                                        >  4195  // #define ListView_GetColumnWidth(hwnd, iCol) (int)SNDMSG((hwnd), LVM_GETCOLUMN
                                                                                        >  4196  
                                                                                        >  4197  enum { LVSCW_AUTOSIZE = -1 }
                                                                                        >  4198  enum { LVSCW_AUTOSIZE_USEHEADER = -2 }
                                                                                        >  4199  enum : uint { LVM_SETCOLUMNWIDTH = LVM_FIRST + 30 }
                                                                                        >  4200  
                                                                                        >  4201  // #define ListView_SetColumnWidth(hwnd, iCol, cx) (BOOL)SNDMSG((hwnd), LVM_SETC
                                                                                        >  4202  
                                                                                        >  4203  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4204  enum : uint { LVM_GETHEADER = LVM_FIRST + 31 }
                                                                                        >  4205  // #define ListView_GetHeader(hwnd) (HWND)SNDMSG((hwnd), LVM_GETHEADER, 0, 0L)
                                                                                        >  4206  // #endif
                                                                                        >  4207  
                                                                                        >  4208  enum : uint { LVM_CREATEDRAGIMAGE = LVM_FIRST + 33 }
                                                                                        >  4209  // #define ListView_CreateDragImage(hwnd, i, lpptUpLeft) (HIMAGELIST)SNDMSG((hwn
                                                                                        >  4210  
                                                                                        >  4211  enum : uint { LVM_GETVIEWRECT = LVM_FIRST + 34 }
                                                                                        >  4212  // #define ListView_GetViewRect(hwnd, prc) (BOOL)SNDMSG((hwnd), LVM_GETVIEWRECT,
                                                                                        >  4213  
                                                                                        >  4214  enum : uint { LVM_GETTEXTCOLOR = LVM_FIRST + 35 }
                                                                                        >  4215  // #define ListView_GetTextColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETTEXTCOLOR
                                                                                        >  4216  
                                                                                        >  4217  enum : uint { LVM_SETTEXTCOLOR = LVM_FIRST + 36 }
                                                                                        >  4218  // #define ListView_SetTextColor(hwnd, clrText) (BOOL)SNDMSG((hwnd), LVM_SETTEXT
                                                                                        >  4219  
                                                                                        >  4220  enum : uint { LVM_GETTEXTBKCOLOR = LVM_FIRST + 37 }
                                                                                        >  4221  // #define ListView_GetTextBkColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETTEXTBKC
                                                                                        >  4222  
                                                                                        >  4223  enum : uint { LVM_SETTEXTBKCOLOR = LVM_FIRST + 38 }
                                                                                        >  4224  // #define ListView_SetTextBkColor(hwnd, clrTextBk) (BOOL)SNDMSG((hwnd), LVM_SET
                                                                                        >  4225  
                                                                                        >  4226  enum : uint { LVM_GETTOPINDEX = LVM_FIRST + 39 }
                                                                                        >  4227  // #define ListView_GetTopIndex(hwndLV) (int)SNDMSG((hwndLV), LVM_GETTOPINDEX, 0
                                                                                        >  4228  
                                                                                        >  4229  enum : uint { LVM_GETCOUNTPERPAGE = LVM_FIRST + 40 }
                                                                                        >  4230  // #define ListView_GetCountPerPage(hwndLV) (int)SNDMSG((hwndLV), LVM_GETCOUNTPE
                                                                                        >  4231  
                                                                                        >  4232  enum : uint { LVM_GETORIGIN = LVM_FIRST + 41 }
                                                                                        >  4233  // #define ListView_GetOrigin(hwndLV, ppt) (BOOL)SNDMSG((hwndLV), LVM_GETORIGIN,
                                                                                        >  4234  
                                                                                        >  4235  enum : uint { LVM_UPDATE = LVM_FIRST + 42 }
                                                                                        >  4236  // #define ListView_Update(hwndLV, i) (BOOL)SNDMSG((hwndLV), LVM_UPDATE, (WPARAM
                                                                                        >  4237  
                                                                                        >  4238  enum : uint { LVM_SETITEMSTATE = LVM_FIRST + 43 }
                                                                                        >  4239  // #define ListView_SetItemState(hwndLV, i, data, mask) { LV_ITEM _ms_lvi; _ms_l
                                                                                        >  4240  
                                                                                        >  4241  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4242  // #define ListView_SetCheckState(hwndLV, i, fCheck) ListView_SetItemState(hwndL
                                                                                        >  4243  // #endif
                                                                                        >  4244  
                                                                                        >  4245  enum : uint { LVM_GETITEMSTATE = LVM_FIRST + 44 }
                                                                                        >  4246  // #define ListView_GetItemState(hwndLV, i, mask) (UINT)SNDMSG((hwndLV), LVM_GET
                                                                                        >  4247  
                                                                                        >  4248  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4249  // #define ListView_GetCheckState(hwndLV, i) ((((UINT)(SNDMSG((hwndLV), LVM_GETI
                                                                                        >  4250  // #endif
                                                                                        >  4251  
                                                                                        >  4252  enum : uint { LVM_GETITEMTEXTA = LVM_FIRST + 45 }
                                                                                        >  4253  enum : uint { LVM_GETITEMTEXTW = LVM_FIRST + 115 }
                                                                                        >  4254  
                                                                                        >  4255  // #ifdef UNICODE
                                                                                        >  4256  // #...
                                                                                        >  4257  // #else
                                                                                        >  4258  alias LVM_GETITEMTEXTA LVM_GETITEMTEXT;
                                                                                        >  4259  // #endif
                                                                                        >  4260  
                                                                                        >  4261  // #define ListView_GetItemText(hwndLV, i, iSubItem_, pszText_, cchTextMax_) { L
                                                                                        >  4262  
                                                                                        >  4263  enum : uint { LVM_SETITEMTEXTA = LVM_FIRST + 46 }
                                                                                        >  4264  enum : uint { LVM_SETITEMTEXTW = LVM_FIRST + 116 }
                                                                                        >  4265  
                                                                                        >  4266  // #ifdef UNICODE
                                                                                        >  4267  // #...
                                                                                        >  4268  // #else
                                                                                        >  4269  alias LVM_SETITEMTEXTA LVM_SETITEMTEXT;
                                                                                        >  4270  // #endif
                                                                                        >  4271  
                                                                                        >  4272  // #define ListView_SetItemText(hwndLV, i, iSubItem_, pszText_) { LV_ITEM _ms_lv
                                                                                        >  4273  
                                                                                        >  4274  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4275  
                                                                                        >  4276  enum : uint { LVSICF_NOINVALIDATEALL = 0x00000001 }
                                                                                        >  4277  enum : uint { LVSICF_NOSCROLL = 0x00000002 }
                                                                                        >  4278  // #endif
                                                                                        >  4279  
                                                                                        >  4280  enum : uint { LVM_SETITEMCOUNT = LVM_FIRST + 47 }
                                                                                        >  4281  // #define ListView_SetItemCount(hwndLV, cItems) SNDMSG((hwndLV), LVM_SETITEMCOU
                                                                                        >  4282  
                                                                                        >  4283  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4284  // #define ListView_SetItemCountEx(hwndLV, cItems, dwFlags) SNDMSG((hwndLV), LVM
                                                                                        >  4285  // #endif
                                                                                        >  4286  
                                                                                        >  4287  extern(Windows) alias int function(LPARAM, LPARAM, LPARAM) PFNLVCOMPARE;
                                                                                        >  4288  
                                                                                        >  4289  enum : uint { LVM_SORTITEMS = LVM_FIRST + 48 }
                                                                                        >  4290  // #define ListView_SortItems(hwndLV, _pfnCompare, _lPrm) (BOOL)SNDMSG((hwndLV),
                                                                                        >  4291  
                                                                                        >  4292  enum : uint { LVM_SETITEMPOSITION32 = LVM_FIRST + 49 }
                                                                                        >  4293  // #define ListView_SetItemPosition32(hwndLV, i, x0, y0) { POINT ptNewPos; ptNew
                                                                                        >  4294  
                                                                                        >  4295  enum : uint { LVM_GETSELECTEDCOUNT = LVM_FIRST + 50 }
                                                                                        >  4296  // #define ListView_GetSelectedCount(hwndLV) (UINT)SNDMSG((hwndLV), LVM_GETSELEC
                                                                                        >  4297  
                                                                                        >  4298  enum : uint { LVM_GETITEMSPACING = LVM_FIRST + 51 }
                                                                                        >  4299  // #define ListView_GetItemSpacing(hwndLV, fSmall) (DWORD)SNDMSG((hwndLV), LVM_G
                                                                                        >  4300  
                                                                                        >  4301  enum : uint { LVM_GETISEARCHSTRINGA = LVM_FIRST + 52 }
                                                                                        >  4302  enum : uint { LVM_GETISEARCHSTRINGW = LVM_FIRST + 117 }
                                                                                        >  4303  
                                                                                        >  4304  // #ifdef UNICODE
                                                                                        >  4305  // #...
                                                                                        >  4306  // #else
                                                                                        >  4307  alias LVM_GETISEARCHSTRINGA LVM_GETISEARCHSTRING;
                                                                                        >  4308  // #endif
                                                                                        >  4309  
                                                                                        >  4310  // #define ListView_GetISearchString(hwndLV, lpsz) (BOOL)SNDMSG((hwndLV), LVM_GE
                                                                                        >  4311  
                                                                                        >  4312  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4313  enum : uint { LVM_SETICONSPACING = LVM_FIRST + 53 }
                                                                                        >  4314  
                                                                                        >  4315  // #define ListView_SetIconSpacing(hwndLV, cx, cy) (DWORD)SNDMSG((hwndLV), LVM_S
                                                                                        >  4316  
                                                                                        >  4317  enum : uint { LVM_SETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 54 }
                                                                                        >  4318  // #define ListView_SetExtendedListViewStyle(hwndLV, dw) (DWORD)SNDMSG((hwndLV),
                                                                                        >  4319  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  4320  // #define ListView_SetExtendedListViewStyleEx(hwndLV, dwMask, dw) (DWORD)SNDMSG
                                                                                        >  4321  // #endif
                                                                                        >  4322  
                                                                                        >  4323  enum : uint { LVM_GETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 55 }
                                                                                        >  4324  // #define ListView_GetExtendedListViewStyle(hwndLV) (DWORD)SNDMSG((hwndLV), LVM
                                                                                        >  4325  
                                                                                        >  4326  enum : uint { LVS_EX_GRIDLINES = 0x00000001 }
                                                                                        >  4327  enum : uint { LVS_EX_SUBITEMIMAGES = 0x00000002 }
                                                                                        >  4328  enum : uint { LVS_EX_CHECKBOXES = 0x00000004 }
                                                                                        >  4329  enum : uint { LVS_EX_TRACKSELECT = 0x00000008 }
                                                                                        >  4330  enum : uint { LVS_EX_HEADERDRAGDROP = 0x00000010 }
                                                                                        >  4331  enum : uint { LVS_EX_FULLROWSELECT = 0x00000020 }
                                                                                        >  4332  enum : uint { LVS_EX_ONECLICKACTIVATE = 0x00000040 }
                                                                                        >  4333  enum : uint { LVS_EX_TWOCLICKACTIVATE = 0x00000080 }
                                                                                        >  4334  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  4335  enum : uint { LVS_EX_FLATSB = 0x00000100 }
                                                                                        >  4336  enum : uint { LVS_EX_REGIONAL = 0x00000200 }
                                                                                        >  4337  enum : uint { LVS_EX_INFOTIP = 0x00000400 }
                                                                                        >  4338  enum : uint { LVS_EX_UNDERLINEHOT = 0x00000800 }
                                                                                        >  4339  enum : uint { LVS_EX_UNDERLINECOLD = 0x00001000 }
                                                                                        >  4340  enum : uint { LVS_EX_MULTIWORKAREAS = 0x00002000 }
                                                                                        >  4341  // #endif
                                                                                        >  4342  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  4343  enum : uint { LVS_EX_LABELTIP = 0x00004000 }
                                                                                        >  4344  enum : uint { LVS_EX_BORDERSELECT = 0x00008000 }
                                                                                        >  4345  // #endif  // End (_WIN32_IE >= 0x0500)
                                                                                        >  4346  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  4347  enum : uint { LVS_EX_DOUBLEBUFFER = 0x00010000 }
                                                                                        >  4348  enum : uint { LVS_EX_HIDELABELS = 0x00020000 }
                                                                                        >  4349  enum : uint { LVS_EX_SINGLEROW = 0x00040000 }
                                                                                        >  4350  enum : uint { LVS_EX_SNAPTOGRID = 0x00080000 }
                                                                                        >  4351  enum : uint { LVS_EX_SIMPLESELECT = 0x00100000 }
                                                                                        >  4352  // #endif
                                                                                        >  4353  
                                                                                        >  4354  enum : uint { LVM_GETSUBITEMRECT = LVM_FIRST + 56 }
                                                                                        >  4355  // #define ListView_GetSubItemRect(hwnd, iItem, iSubItem, code, prc) (BOOL)SNDMS
                                                                                        >  4356  
                                                                                        >  4357  enum : uint { LVM_SUBITEMHITTEST = LVM_FIRST + 57 }
                                                                                        >  4358  // #define ListView_SubItemHitTest(hwnd, plvhti) (int)SNDMSG((hwnd), LVM_SUBITEM
                                                                                        >  4359  
                                                                                        >  4360  enum : uint { LVM_SETCOLUMNORDERARRAY = LVM_FIRST + 58 }
                                                                                        >  4361  // #define ListView_SetColumnOrderArray(hwnd, iCount, pi) (BOOL)SNDMSG((hwnd), L
                                                                                        >  4362  
                                                                                        >  4363  enum : uint { LVM_GETCOLUMNORDERARRAY = LVM_FIRST + 59 }
                                                                                        >  4364  // #define ListView_GetColumnOrderArray(hwnd, iCount, pi) (BOOL)SNDMSG((hwnd), L
                                                                                        >  4365  
                                                                                        >  4366  enum : uint { LVM_SETHOTITEM = LVM_FIRST + 60 }
                                                                                        >  4367  // #define ListView_SetHotItem(hwnd, i) (int)SNDMSG((hwnd), LVM_SETHOTITEM, (WPA
                                                                                        >  4368  
                                                                                        >  4369  enum : uint { LVM_GETHOTITEM = LVM_FIRST + 61 }
                                                                                        >  4370  // #define ListView_GetHotItem(hwnd) (int)SNDMSG((hwnd), LVM_GETHOTITEM, 0, 0)
                                                                                        >  4371  
                                                                                        >  4372  enum : uint { LVM_SETHOTCURSOR = LVM_FIRST + 62 }
                                                                                        >  4373  // #define ListView_SetHotCursor(hwnd, hcur) (HCURSOR)SNDMSG((hwnd), LVM_SETHOTC
                                                                                        >  4374  
                                                                                        >  4375  enum : uint { LVM_GETHOTCURSOR = LVM_FIRST + 63 }
                                                                                        >  4376  // #define ListView_GetHotCursor(hwnd) (HCURSOR)SNDMSG((hwnd), LVM_GETHOTCURSOR,
                                                                                        >  4377  
                                                                                        >  4378  enum : uint { LVM_APPROXIMATEVIEWRECT = LVM_FIRST + 64 }
                                                                                        >  4379  // #define ListView_ApproximateViewRect(hwnd, iWidth, iHeight, iCount) (DWORD)SN
                                                                                        >  4380  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  4381  
                                                                                        >  4382  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  4383  
                                                                                        >  4384  enum : uint { LV_MAX_WORKAREAS = 16 }
                                                                                        >  4385  enum : uint { LVM_SETWORKAREAS = LVM_FIRST + 65 }
                                                                                        >  4386  // #define ListView_SetWorkAreas(hwnd, nWorkAreas, prc) (BOOL)SNDMSG((hwnd), LVM
                                                                                        >  4387  
                                                                                        >  4388  enum : uint { LVM_GETWORKAREAS = LVM_FIRST + 70 }
                                                                                        >  4389  // #define ListView_GetWorkAreas(hwnd, nWorkAreas, prc) (BOOL)SNDMSG((hwnd), LVM
                                                                                        >  4390  
                                                                                        >  4391  enum : uint { LVM_GETNUMBEROFWORKAREAS = LVM_FIRST + 73 }
                                                                                        >  4392  // #define ListView_GetNumberOfWorkAreas(hwnd, pnWorkAreas) (BOOL)SNDMSG((hwnd),
                                                                                        >  4393  
                                                                                        >  4394  enum : uint { LVM_GETSELECTIONMARK = LVM_FIRST + 66 }
                                                                                        >  4395  // #define ListView_GetSelectionMark(hwnd) (int)SNDMSG((hwnd), LVM_GETSELECTIONM
                                                                                        >  4396  
                                                                                        >  4397  enum : uint { LVM_SETSELECTIONMARK = LVM_FIRST + 67 }
                                                                                        >  4398  // #define ListView_SetSelectionMark(hwnd, i) (int)SNDMSG((hwnd), LVM_SETSELECTI
                                                                                        >  4399  
                                                                                        >  4400  enum : uint { LVM_SETHOVERTIME = LVM_FIRST + 71 }
                                                                                        >  4401  // #define ListView_SetHoverTime(hwndLV, dwHoverTimeMs) (DWORD)SNDMSG((hwndLV), 
                                                                                        >  4402  
                                                                                        >  4403  enum : uint { LVM_GETHOVERTIME = LVM_FIRST + 72 }
                                                                                        >  4404  // #define ListView_GetHoverTime(hwndLV) (DWORD)SNDMSG((hwndLV), LVM_GETHOVERTIM
                                                                                        >  4405  
                                                                                        >  4406  enum : uint { LVM_SETTOOLTIPS = LVM_FIRST + 74 }
                                                                                        >  4407  // #define ListView_SetToolTips(hwndLV, hwndNewHwnd) (HWND)SNDMSG((hwndLV), LVM_
                                                                                        >  4408  
                                                                                        >  4409  enum : uint { LVM_GETTOOLTIPS = LVM_FIRST + 78 }
                                                                                        >  4410  // #define ListView_GetToolTips(hwndLV) (HWND)SNDMSG((hwndLV), LVM_GETTOOLTIPS, 
                                                                                        >  4411  
                                                                                        >  4412  enum : uint { LVM_SORTITEMSEX = LVM_FIRST + 81 }
                                                                                        >  4413  // #define ListView_SortItemsEx(hwndLV, _pfnCompare, _lPrm) (BOOL)SNDMSG((hwndLV
                                                                                        >  4414  
                                                                                        >  4415  struct tagLVBKIMAGEA {
                                                                                        >  4416    ULONG ulFlags;
                                                                                        >  4417    HBITMAP hbm;
                                                                                        >  4418    LPSTR pszImage;
                                                                                        >  4419    UINT cchImageMax;
                                                                                        >  4420    int xOffsetPercent;
                                                                                        >  4421    int yOffsetPercent;
                                                                                        >  4422  }
                                                                                        >  4423  alias tagLVBKIMAGEA LVBKIMAGEA;
                                                                                        >  4424  alias tagLVBKIMAGEA* LPLVBKIMAGEA;
                                                                                        >  4425  
                                                                                        >  4426  struct tagLVBKIMAGEW {
                                                                                        >  4427    ULONG ulFlags;
                                                                                        >  4428    HBITMAP hbm;
                                                                                        >  4429    LPWSTR pszImage;
                                                                                        >  4430    UINT cchImageMax;
                                                                                        >  4431    int xOffsetPercent;
                                                                                        >  4432    int yOffsetPercent;
                                                                                        >  4433  }
                                                                                        >  4434  alias tagLVBKIMAGEW LVBKIMAGEW;
                                                                                        >  4435  alias tagLVBKIMAGEW* LPLVBKIMAGEW;
                                                                                        >  4436  
                                                                                        >  4437  enum : uint { LVBKIF_SOURCE_NONE = 0x00000000 }
                                                                                        >  4438  enum : uint { LVBKIF_SOURCE_HBITMAP = 0x00000001 }
                                                                                        >  4439  enum : uint { LVBKIF_SOURCE_URL = 0x00000002 }
                                                                                        >  4440  enum : uint { LVBKIF_SOURCE_MASK = 0x00000003 }
                                                                                        >  4441  enum : uint { LVBKIF_STYLE_NORMAL = 0x00000000 }
                                                                                        >  4442  enum : uint { LVBKIF_STYLE_TILE = 0x00000010 }
                                                                                        >  4443  enum : uint { LVBKIF_STYLE_MASK = 0x00000010 }
                                                                                        >  4444  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  4445  enum : uint { LVBKIF_FLAG_TILEOFFSET = 0x00000100 }
                                                                                        >  4446  enum : uint { LVBKIF_TYPE_WATERMARK = 0x10000000 }
                                                                                        >  4447  // #endif
                                                                                        >  4448  
                                                                                        >  4449  enum : uint { LVM_SETBKIMAGEA = LVM_FIRST + 68 }
                                                                                        >  4450  enum : uint { LVM_SETBKIMAGEW = LVM_FIRST + 138 }
                                                                                        >  4451  enum : uint { LVM_GETBKIMAGEA = LVM_FIRST + 69 }
                                                                                        >  4452  enum : uint { LVM_GETBKIMAGEW = LVM_FIRST + 139 }
                                                                                        >  4453  
                                                                                        >  4454  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  4455  enum : uint { LVM_SETSELECTEDCOLUMN = LVM_FIRST + 140 }
                                                                                        >  4456  // #define ListView_SetSelectedColumn(hwnd, iCol) SNDMSG((hwnd), LVM_SETSELECTED
                                                                                        >  4457  
                                                                                        >  4458  enum : uint { LVM_SETTILEWIDTH = LVM_FIRST + 141 }
                                                                                        >  4459  // #define ListView_SetTileWidth(hwnd, cpWidth) SNDMSG((hwnd), LVM_SETTILEWIDTH,
                                                                                        >  4460  
                                                                                        >  4461  enum : uint { LV_VIEW_ICON = 0x0000 }
                                                                                        >  4462  enum : uint { LV_VIEW_DETAILS = 0x0001 }
                                                                                        >  4463  enum : uint { LV_VIEW_SMALLICON = 0x0002 }
                                                                                        >  4464  enum : uint { LV_VIEW_LIST = 0x0003 }
                                                                                        >  4465  enum : uint { LV_VIEW_TILE = 0x0004 }
                                                                                        >  4466  enum : uint { LV_VIEW_MAX = 0x0004 }
                                                                                        >  4467  
                                                                                        >  4468  enum : uint { LVM_SETVIEW = LVM_FIRST + 142 }
                                                                                        >  4469  // #define ListView_SetView(hwnd, iView) (DWORD)SNDMSG((hwnd), LVM_SETVIEW, (WPA
                                                                                        >  4470  
                                                                                        >  4471  enum : uint { LVM_GETVIEW = LVM_FIRST + 143 }
                                                                                        >  4472  // #define ListView_GetView(hwnd) (DWORD)SNDMSG((hwnd), LVM_GETVIEW, 0, 0)
                                                                                        >  4473  
                                                                                        >  4474  enum : uint { LVGF_NONE = 0x00000000 }
                                                                                        >  4475  enum : uint { LVGF_HEADER = 0x00000001 }
                                                                                        >  4476  enum : uint { LVGF_FOOTER = 0x00000002 }
                                                                                        >  4477  enum : uint { LVGF_STATE = 0x00000004 }
                                                                                        >  4478  enum : uint { LVGF_ALIGN = 0x00000008 }
                                                                                        >  4479  enum : uint { LVGF_GROUPID = 0x00000010 }
                                                                                        >  4480  
                                                                                        >  4481  enum : uint { LVGS_NORMAL = 0x00000000 }
                                                                                        >  4482  enum : uint { LVGS_COLLAPSED = 0x00000001 }
                                                                                        >  4483  enum : uint { LVGS_HIDDEN = 0x00000002 }
                                                                                        >  4484  
                                                                                        >  4485  enum : uint { LVGA_HEADER_LEFT = 0x00000001 }
                                                                                        >  4486  enum : uint { LVGA_HEADER_CENTER = 0x00000002 }
                                                                                        >  4487  enum : uint { LVGA_HEADER_RIGHT = 0x00000004 }
                                                                                        >  4488  enum : uint { LVGA_FOOTER_LEFT = 0x00000008 }
                                                                                        >  4489  enum : uint { LVGA_FOOTER_CENTER = 0x00000010 }
                                                                                        >  4490  enum : uint { LVGA_FOOTER_RIGHT = 0x00000020 }
                                                                                        >  4491  
                                                                                        >  4492  struct tagLVGROUP {
                                                                                        >  4493    UINT cbSize;
                                                                                        >  4494    UINT mask;
                                                                                        >  4495    LPWSTR pszHeader;
                                                                                        >  4496    int cchHeader;
                                                                                        >  4497    LPWSTR pszFooter;
                                                                                        >  4498    int cchFooter;
                                                                                        >  4499    int iGroupId;
                                                                                        >  4500    UINT stateMask;
                                                                                        >  4501    UINT state;
                                                                                        >  4502    UINT uAlign;
                                                                                        >  4503  }
                                                                                        >  4504  alias tagLVGROUP LVGROUP;
                                                                                        >  4505  alias tagLVGROUP* PLVGROUP;
                                                                                        >  4506  
                                                                                        >  4507  enum : uint { LVM_INSERTGROUP = LVM_FIRST + 145 }
                                                                                        >  4508  // #define ListView_InsertGroup(hwnd, index, pgrp) SNDMSG((hwnd), LVM_INSERTGROU
                                                                                        >  4509  
                                                                                        >  4510  enum : uint { LVM_SETGROUPINFO = LVM_FIRST + 147 }
                                                                                        >  4511  // #define ListView_SetGroupInfo(hwnd, iGroupId, pgrp) SNDMSG((hwnd), LVM_SETGRO
                                                                                        >  4512  
                                                                                        >  4513  enum : uint { LVM_GETGROUPINFO = LVM_FIRST + 149 }
                                                                                        >  4514  // #define ListView_GetGroupInfo(hwnd, iGroupId, pgrp) SNDMSG((hwnd), LVM_GETGRO
                                                                                        >  4515  
                                                                                        >  4516  enum : uint { LVM_REMOVEGROUP = LVM_FIRST + 150 }
                                                                                        >  4517  // #define ListView_RemoveGroup(hwnd, iGroupId) SNDMSG((hwnd), LVM_REMOVEGROUP, 
                                                                                        >  4518  
                                                                                        >  4519  enum : uint { LVM_MOVEGROUP = LVM_FIRST + 151 }
                                                                                        >  4520  // #define ListView_MoveGroup(hwnd, iGroupId, toIndex) SNDMSG((hwnd), LVM_MOVEGR
                                                                                        >  4521  
                                                                                        >  4522  enum : uint { LVM_MOVEITEMTOGROUP = LVM_FIRST + 154 }
                                                                                        >  4523  // #define ListView_MoveItemToGroup(hwnd, idItemFrom, idGroupTo) SNDMSG((hwnd), 
                                                                                        >  4524  
                                                                                        >  4525  enum : uint { LVGMF_NONE = 0x00000000 }
                                                                                        >  4526  enum : uint { LVGMF_BORDERSIZE = 0x00000001 }
                                                                                        >  4527  enum : uint { LVGMF_BORDERCOLOR = 0x00000002 }
                                                                                        >  4528  enum : uint { LVGMF_TEXTCOLOR = 0x00000004 }
                                                                                        >  4529  
                                                                                        >  4530  struct tagLVGROUPMETRICS {
                                                                                        >  4531    UINT cbSize;
                                                                                        >  4532    UINT mask;
                                                                                        >  4533    UINT Left;
                                                                                        >  4534    UINT Top;
                                                                                        >  4535    UINT Right;
                                                                                        >  4536    UINT Bottom;
                                                                                        >  4537    COLORREF crLeft;
                                                                                        >  4538    COLORREF crTop;
                                                                                        >  4539    COLORREF crRight;
                                                                                        >  4540    COLORREF crBottom;
                                                                                        >  4541    COLORREF crHeader;
                                                                                        >  4542    COLORREF crFooter;
                                                                                        >  4543  }
                                                                                        >  4544  alias tagLVGROUPMETRICS LVGROUPMETRICS;
                                                                                        >  4545  alias tagLVGROUPMETRICS* PLVGROUPMETRICS;
                                                                                        >  4546  
                                                                                        >  4547  enum : uint { LVM_SETGROUPMETRICS = LVM_FIRST + 155 }
                                                                                        >  4548  // #define ListView_SetGroupMetrics(hwnd, pGroupMetrics) SNDMSG((hwnd), LVM_SETG
                                                                                        >  4549  
                                                                                        >  4550  enum : uint { LVM_GETGROUPMETRICS = LVM_FIRST + 156 }
                                                                                        >  4551  // #define ListView_GetGroupMetrics(hwnd, pGroupMetrics) SNDMSG((hwnd), LVM_GETG
                                                                                        >  4552  
                                                                                        >  4553  enum : uint { LVM_ENABLEGROUPVIEW = LVM_FIRST + 157 }
                                                                                        >  4554  // #define ListView_EnableGroupView(hwnd, fEnable) SNDMSG((hwnd), LVM_ENABLEGROU
                                                                                        >  4555  
                                                                                        >  4556  extern(Windows) alias int function(int, int, void *) PFNLVGROUPCOMPARE;
                                                                                        >  4557  
                                                                                        >  4558  enum : uint { LVM_SORTGROUPS = LVM_FIRST + 158 }
                                                                                        >  4559  // #define ListView_SortGroups(hwnd, _pfnGroupCompate, _plv) SNDMSG((hwnd), LVM_
                                                                                        >  4560  
                                                                                        >  4561  struct tagLVINSERTGROUPSORTED {
                                                                                        >  4562    PFNLVGROUPCOMPARE pfnGroupCompare;
                                                                                        >  4563    void *pvData;
                                                                                        >  4564    LVGROUP lvGroup;
                                                                                        >  4565  }
                                                                                        >  4566  alias tagLVINSERTGROUPSORTED LVINSERTGROUPSORTED;
                                                                                        >  4567  alias tagLVINSERTGROUPSORTED* PLVINSERTGROUPSORTED;
                                                                                        >  4568  
                                                                                        >  4569  enum : uint { LVM_INSERTGROUPSORTED = LVM_FIRST + 159 }
                                                                                        >  4570  // #define ListView_InsertGroupSorted(hwnd, structInsert) SNDMSG((hwnd), LVM_INS
                                                                                        >  4571  
                                                                                        >  4572  enum : uint { LVM_REMOVEALLGROUPS = LVM_FIRST + 160 }
                                                                                        >  4573  // #define ListView_RemoveAllGroups(hwnd) SNDMSG((hwnd), LVM_REMOVEALLGROUPS, 0,
                                                                                        >  4574  
                                                                                        >  4575  enum : uint { LVM_HASGROUP = LVM_FIRST + 161 }
                                                                                        >  4576  // #define ListView_HasGroup(hwnd, dwGroupId) SNDMSG((hwnd), LVM_HASGROUP, dwGro
                                                                                        >  4577  
                                                                                        >  4578  enum : uint { LVTVIF_AUTOSIZE = 0x00000000 }
                                                                                        >  4579  enum : uint { LVTVIF_FIXEDWIDTH = 0x00000001 }
                                                                                        >  4580  enum : uint { LVTVIF_FIXEDHEIGHT = 0x00000002 }
                                                                                        >  4581  enum : uint { LVTVIF_FIXEDSIZE = 0x00000003 }
                                                                                        >  4582  
                                                                                        >  4583  enum : uint { LVTVIM_TILESIZE = 0x00000001 }
                                                                                        >  4584  enum : uint { LVTVIM_COLUMNS = 0x00000002 }
                                                                                        >  4585  enum : uint { LVTVIM_LABELMARGIN = 0x00000004 }
                                                                                        >  4586  
                                                                                        >  4587  struct tagLVTILEVIEWINFO {
                                                                                        >  4588    UINT cbSize;
                                                                                        >  4589    DWORD dwMask;
                                                                                        >  4590    DWORD dwFlags;
                                                                                        >  4591    SIZE sizeTile;
                                                                                        >  4592    int cLines;
                                                                                        >  4593    RECT rcLabelMargin;
                                                                                        >  4594  }
                                                                                        >  4595  alias tagLVTILEVIEWINFO LVTILEVIEWINFO;
                                                                                        >  4596  alias tagLVTILEVIEWINFO* PLVTILEVIEWINFO;
                                                                                        >  4597  
                                                                                        >  4598  struct tagLVTILEINFO {
                                                                                        >  4599    UINT cbSize;
                                                                                        >  4600    int iItem;
                                                                                        >  4601    UINT cColumns;
                                                                                        >  4602    PUINT puColumns;
                                                                                        >  4603  }
                                                                                        >  4604  alias tagLVTILEINFO LVTILEINFO;
                                                                                        >  4605  alias tagLVTILEINFO* PLVTILEINFO;
                                                                                        >  4606  
                                                                                        >  4607  enum : uint { LVM_SETTILEVIEWINFO = LVM_FIRST + 162 }
                                                                                        >  4608  // #define ListView_SetTileViewInfo(hwnd, ptvi) SNDMSG((hwnd), LVM_SETTILEVIEWIN
                                                                                        >  4609  
                                                                                        >  4610  enum : uint { LVM_GETTILEVIEWINFO = LVM_FIRST + 163 }
                                                                                        >  4611  // #define ListView_GetTileViewInfo(hwnd, ptvi) SNDMSG((hwnd), LVM_GETTILEVIEWIN
                                                                                        >  4612  
                                                                                        >  4613  enum : uint { LVM_SETTILEINFO = LVM_FIRST + 164 }
                                                                                        >  4614  // #define ListView_SetTileInfo(hwnd, pti) SNDMSG((hwnd), LVM_SETTILEINFO, 0, (L
                                                                                        >  4615  
                                                                                        >  4616  enum : uint { LVM_GETTILEINFO = LVM_FIRST + 165 }
                                                                                        >  4617  // #define ListView_GetTileInfo(hwnd, pti) SNDMSG((hwnd), LVM_GETTILEINFO, 0, (L
                                                                                        >  4618  
                                                                                        >  4619  struct _8 {
                                                                                        >  4620    UINT cbSize;
                                                                                        >  4621    DWORD dwFlags;
                                                                                        >  4622    int iItem;
                                                                                        >  4623    DWORD dwReserved;
                                                                                        >  4624  }
                                                                                        >  4625  alias _8 LVINSERTMARK;
                                                                                        >  4626  alias _8* LPLVINSERTMARK;
                                                                                        >  4627  
                                                                                        >  4628  enum : uint { LVIM_AFTER = 0x00000001 }
                                                                                        >  4629  
                                                                                        >  4630  enum : uint { LVM_SETINSERTMARK = LVM_FIRST + 166 }
                                                                                        >  4631  // #define ListView_SetInsertMark(hwnd, lvim) (BOOL)SNDMSG((hwnd), LVM_SETINSERT
                                                                                        >  4632  
                                                                                        >  4633  enum : uint { LVM_GETINSERTMARK = LVM_FIRST + 167 }
                                                                                        >  4634  // #define ListView_GetInsertMark(hwnd, lvim) (BOOL)SNDMSG((hwnd), LVM_GETINSERT
                                                                                        >  4635  
                                                                                        >  4636  enum : uint { LVM_INSERTMARKHITTEST = LVM_FIRST + 168 }
                                                                                        >  4637  // #define ListView_InsertMarkHitTest(hwnd, point, lvim) (int)SNDMSG((hwnd), LVM
                                                                                        >  4638  
                                                                                        >  4639  enum : uint { LVM_GETINSERTMARKRECT = LVM_FIRST + 169 }
                                                                                        >  4640  // #define ListView_GetInsertMarkRect(hwnd, rc) (int)SNDMSG((hwnd), LVM_GETINSER
                                                                                        >  4641  
                                                                                        >  4642  enum : uint { LVM_SETINSERTMARKCOLOR = LVM_FIRST + 170 }
                                                                                        >  4643  // #define ListView_SetInsertMarkColor(hwnd, color) (COLORREF)SNDMSG((hwnd), LVM
                                                                                        >  4644  
                                                                                        >  4645  enum : uint { LVM_GETINSERTMARKCOLOR = LVM_FIRST + 171 }
                                                                                        >  4646  // #define ListView_GetInsertMarkColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETINS
                                                                                        >  4647  
                                                                                        >  4648  struct tagLVSETINFOTIP {
                                                                                        >  4649    UINT cbSize;
                                                                                        >  4650    DWORD dwFlags;
                                                                                        >  4651    LPWSTR pszText;
                                                                                        >  4652    int iItem;
                                                                                        >  4653    int iSubItem;
                                                                                        >  4654  }
                                                                                        >  4655  alias tagLVSETINFOTIP LVSETINFOTIP;
                                                                                        >  4656  alias tagLVSETINFOTIP* PLVSETINFOTIP;
                                                                                        >  4657  
                                                                                        >  4658  enum : uint { LVM_SETINFOTIP = LVM_FIRST + 173 }
                                                                                        >  4659  
                                                                                        >  4660  // #define ListView_SetInfoTip(hwndLV, plvInfoTip) (BOOL)SNDMSG((hwndLV), LVM_SE
                                                                                        >  4661  
                                                                                        >  4662  enum : uint { LVM_GETSELECTEDCOLUMN = LVM_FIRST + 174 }
                                                                                        >  4663  // #define ListView_GetSelectedColumn(hwnd) (UINT)SNDMSG((hwnd), LVM_GETSELECTED
                                                                                        >  4664  
                                                                                        >  4665  enum : uint { LVM_ISGROUPVIEWENABLED = LVM_FIRST + 175 }
                                                                                        >  4666  // #define ListView_IsGroupViewEnabled(hwnd) (BOOL)SNDMSG((hwnd), LVM_ISGROUPVIE
                                                                                        >  4667  
                                                                                        >  4668  enum : uint { LVM_GETOUTLINECOLOR = LVM_FIRST + 176 }
                                                                                        >  4669  // #define ListView_GetOutlineColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETOUTLIN
                                                                                        >  4670  
                                                                                        >  4671  enum : uint { LVM_SETOUTLINECOLOR = LVM_FIRST + 177 }
                                                                                        >  4672  // #define ListView_SetOutlineColor(hwnd, color) (COLORREF)SNDMSG((hwnd), LVM_SE
                                                                                        >  4673  
                                                                                        >  4674  enum : uint { LVM_CANCELEDITLABEL = LVM_FIRST + 179 }
                                                                                        >  4675  // #define ListView_CancelEditLabel(hwnd) (VOID)SNDMSG((hwnd), LVM_CANCELEDITLAB
                                                                                        >  4676  
                                                                                        >  4677  enum : uint { LVM_MAPINDEXTOID = LVM_FIRST + 180 }
                                                                                        >  4678  // #define ListView_MapIndexToID(hwnd, index) (UINT)SNDMSG((hwnd), LVM_MAPINDEXT
                                                                                        >  4679  
                                                                                        >  4680  enum : uint { LVM_MAPIDTOINDEX = LVM_FIRST + 181 }
                                                                                        >  4681  // #define ListView_MapIDToIndex(hwnd, id) (UINT)SNDMSG((hwnd), LVM_MAPIDTOINDEX
                                                                                        >  4682  
                                                                                        >  4683  // #endif
                                                                                        >  4684  
                                                                                        >  4685  // #ifdef UNICODE
                                                                                        >  4686  // #...
                                                                                        >  4687  // #...
                                                                                        >  4688  // #...
                                                                                        >  4689  // #...
                                                                                        >  4690  // #else
                                                                                        >  4691  alias LVBKIMAGEA LVBKIMAGE;
                                                                                        >  4692  alias LPLVBKIMAGEA LPLVBKIMAGE;
                                                                                        >  4693  alias LVM_SETBKIMAGEA LVM_SETBKIMAGE;
                                                                                        >  4694  alias LVM_GETBKIMAGEA LVM_GETBKIMAGE;
                                                                                        >  4695  // #endif
                                                                                        >  4696  
                                                                                        >  4697  // #define ListView_SetBkImage(hwnd, plvbki) (BOOL)SNDMSG((hwnd), LVM_SETBKIMAGE
                                                                                        >  4698  
                                                                                        >  4699  // #define ListView_GetBkImage(hwnd, plvbki) (BOOL)SNDMSG((hwnd), LVM_GETBKIMAGE
                                                                                        >  4700  
                                                                                        >  4701  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  4702  
                                                                                        >  4703  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4704  alias LPNMLISTVIEW LPNM_LISTVIEW;
                                                                                        >  4705  alias NMLISTVIEW NM_LISTVIEW;
                                                                                        >  4706  // #else
                                                                                        >  4707  // #...
                                                                                        >  4708  // #...
                                                                                        >  4709  // #...
                                                                                        >  4710  // #endif
                                                                                        >  4711  
                                                                                        >  4712  struct tagNMLISTVIEW {
                                                                                        >  4713    NMHDR hdr;
                                                                                        >  4714    int iItem;
                                                                                        >  4715    int iSubItem;
                                                                                        >  4716    UINT uNewState;
                                                                                        >  4717    UINT uOldState;
                                                                                        >  4718    UINT uChanged;
                                                                                        >  4719    POINT ptAction;
                                                                                        >  4720    LPARAM lParam;
                                                                                        >  4721  }
                                                                                        >  4722  alias tagNMLISTVIEW NMLISTVIEW;
                                                                                        >  4723  alias tagNMLISTVIEW* LPNMLISTVIEW;
                                                                                        >  4724  
                                                                                        >  4725  // #if (_WIN32_IE >= 0x400)
                                                                                        >  4726  
                                                                                        >  4727  struct tagNMITEMACTIVATE {
                                                                                        >  4728    NMHDR hdr;
                                                                                        >  4729    int iItem;
                                                                                        >  4730    int iSubItem;
                                                                                        >  4731    UINT uNewState;
                                                                                        >  4732    UINT uOldState;
                                                                                        >  4733    UINT uChanged;
                                                                                        >  4734    POINT ptAction;
                                                                                        >  4735    LPARAM lParam;
                                                                                        >  4736    UINT uKeyFlags;
                                                                                        >  4737  }
                                                                                        >  4738  alias tagNMITEMACTIVATE NMITEMACTIVATE;
                                                                                        >  4739  alias tagNMITEMACTIVATE* LPNMITEMACTIVATE;
                                                                                        >  4740  
                                                                                        >  4741  enum : uint { LVKF_ALT = 0x0001 }
                                                                                        >  4742  enum : uint { LVKF_CONTROL = 0x0002 }
                                                                                        >  4743  enum : uint { LVKF_SHIFT = 0x0004 }
                                                                                        >  4744  // #endif //(_WIN32_IE >= 0x0400)
                                                                                        >  4745  
                                                                                        >  4746  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4747  // #define NMLVCUSTOMDRAW_V3_SIZE CCSIZEOF_STRUCT(NMLVCUSTOMDRW, clrTextBk)
                                                                                        >  4748  
                                                                                        >  4749  struct tagNMLVCUSTOMDRAW {
                                                                                        >  4750    NMCUSTOMDRAW nmcd;
                                                                                        >  4751    COLORREF clrText;
                                                                                        >  4752    COLORREF clrTextBk;
                                                                                        >  4753  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  4754    int iSubItem;
                                                                                        >  4755  // #endif
                                                                                        >  4756  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  4757    DWORD dwItemType;
                                                                                        >  4758    COLORREF clrFace;
                                                                                        >  4759    int iIconEffect;
                                                                                        >  4760    int iIconPhase;
                                                                                        >  4761    int iPartId;
                                                                                        >  4762    int iStateId;
                                                                                        >  4763    RECT rcText;
                                                                                        >  4764    UINT uAlign;
                                                                                        >  4765  // #endif
                                                                                        >  4766  }
                                                                                        >  4767  alias tagNMLVCUSTOMDRAW NMLVCUSTOMDRAW;
                                                                                        >  4768  alias tagNMLVCUSTOMDRAW* LPNMLVCUSTOMDRAW;
                                                                                        >  4769  
                                                                                        >  4770  enum : uint { LVCDI_ITEM = 0x00000000 }
                                                                                        >  4771  enum : uint { LVCDI_GROUP = 0x00000001 }
                                                                                        >  4772  
                                                                                        >  4773  enum : uint { LVCDRF_NOSELECT = 0x00010000 }
                                                                                        >  4774  enum : uint { LVCDRF_NOGROUPFRAME = 0x00020000 }
                                                                                        >  4775  
                                                                                        >  4776  struct tagNMLVCACHEHINT {
                                                                                        >  4777    NMHDR hdr;
                                                                                        >  4778    int iFrom;
                                                                                        >  4779    int iTo;
                                                                                        >  4780  }
                                                                                        >  4781  alias tagNMLVCACHEHINT NMLVCACHEHINT;
                                                                                        >  4782  alias tagNMLVCACHEHINT* LPNMLVCACHEHINT;
                                                                                        >  4783  
                                                                                        >  4784  alias LPNMLVCACHEHINT LPNM_CACHEHINT;
                                                                                        >  4785  alias LPNMLVCACHEHINT PNM_CACHEHINT;
                                                                                        >  4786  alias NMLVCACHEHINT NM_CACHEHINT;
                                                                                        >  4787  
                                                                                        >  4788  struct tagNMLVFINDITEMA {
                                                                                        >  4789    NMHDR hdr;
                                                                                        >  4790    int iStart;
                                                                                        >  4791    LVFINDINFOA lvfi;
                                                                                        >  4792  }
                                                                                        >  4793  alias tagNMLVFINDITEMA NMLVFINDITEMA;
                                                                                        >  4794  alias tagNMLVFINDITEMA* LPNMLVFINDITEMA;
                                                                                        >  4795  
                                                                                        >  4796  struct tagNMLVFINDITEMW {
                                                                                        >  4797    NMHDR hdr;
                                                                                        >  4798    int iStart;
                                                                                        >  4799    LVFINDINFOW lvfi;
                                                                                        >  4800  }
                                                                                        >  4801  alias tagNMLVFINDITEMW NMLVFINDITEMW;
                                                                                        >  4802  alias tagNMLVFINDITEMW* LPNMLVFINDITEMW;
                                                                                        >  4803  
                                                                                        >  4804  alias LPNMLVFINDITEMA PNM_FINDITEMA;
                                                                                        >  4805  alias LPNMLVFINDITEMA LPNM_FINDITEMA;
                                                                                        >  4806  alias NMLVFINDITEMA NM_FINDITEMA;
                                                                                        >  4807  
                                                                                        >  4808  alias LPNMLVFINDITEMW PNM_FINDITEMW;
                                                                                        >  4809  alias LPNMLVFINDITEMW LPNM_FINDITEMW;
                                                                                        >  4810  alias NMLVFINDITEMW NM_FINDITEMW;
                                                                                        >  4811  
                                                                                        >  4812  // #ifdef UNICODE
                                                                                        >  4813  // #...
                                                                                        >  4814  // #...
                                                                                        >  4815  // #...
                                                                                        >  4816  // #...
                                                                                        >  4817  // #...
                                                                                        >  4818  // #else
                                                                                        >  4819  alias PNM_FINDITEMA PNM_FINDITEM;
                                                                                        >  4820  alias LPNM_FINDITEMA LPNM_FINDITEM;
                                                                                        >  4821  alias NM_FINDITEMA NM_FINDITEM;
                                                                                        >  4822  alias NMLVFINDITEMA NMLVFINDITEM;
                                                                                        >  4823  alias LPNMLVFINDITEMA LPNMLVFINDITEM;
                                                                                        >  4824  // #endif
                                                                                        >  4825  
                                                                                        >  4826  struct tagNMLVODSTATECHANGE {
                                                                                        >  4827    NMHDR hdr;
                                                                                        >  4828    int iFrom;
                                                                                        >  4829    int iTo;
                                                                                        >  4830    UINT uNewState;
                                                                                        >  4831    UINT uOldState;
                                                                                        >  4832  }
                                                                                        >  4833  alias tagNMLVODSTATECHANGE NMLVODSTATECHANGE;
                                                                                        >  4834  alias tagNMLVODSTATECHANGE* LPNMLVODSTATECHANGE;
                                                                                        >  4835  
                                                                                        >  4836  alias LPNMLVODSTATECHANGE PNM_ODSTATECHANGE;
                                                                                        >  4837  alias LPNMLVODSTATECHANGE LPNM_ODSTATECHANGE;
                                                                                        >  4838  alias NMLVODSTATECHANGE NM_ODSTATECHANGE;
                                                                                        >  4839  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  4840  
                                                                                        >  4841  enum : uint { LVN_ITEMCHANGING = LVN_FIRST-0 }
                                                                                        >  4842  enum : uint { LVN_ITEMCHANGED = LVN_FIRST-1 }
                                                                                        >  4843  enum : uint { LVN_INSERTITEM = LVN_FIRST-2 }
                                                                                        >  4844  enum : uint { LVN_DELETEITEM = LVN_FIRST-3 }
                                                                                        >  4845  enum : uint { LVN_DELETEALLITEMS = LVN_FIRST-4 }
                                                                                        >  4846  enum : uint { LVN_BEGINLABELEDITA = LVN_FIRST-5 }
                                                                                        >  4847  enum : uint { LVN_BEGINLABELEDITW = LVN_FIRST-75 }
                                                                                        >  4848  enum : uint { LVN_ENDLABELEDITA = LVN_FIRST-6 }
                                                                                        >  4849  enum : uint { LVN_ENDLABELEDITW = LVN_FIRST-76 }
                                                                                        >  4850  enum : uint { LVN_COLUMNCLICK = LVN_FIRST-8 }
                                                                                        >  4851  enum : uint { LVN_BEGINDRAG = LVN_FIRST-9 }
                                                                                        >  4852  enum : uint { LVN_BEGINRDRAG = LVN_FIRST-11 }
                                                                                        >  4853  
                                                                                        >  4854  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4855  enum : uint { LVN_ODCACHEHINT = LVN_FIRST-13 }
                                                                                        >  4856  enum : uint { LVN_ODFINDITEMA = LVN_FIRST-52 }
                                                                                        >  4857  enum : uint { LVN_ODFINDITEMW = LVN_FIRST-79 }
                                                                                        >  4858  
                                                                                        >  4859  enum : uint { LVN_ITEMACTIVATE = LVN_FIRST-14 }
                                                                                        >  4860  enum : uint { LVN_ODSTATECHANGED = LVN_FIRST-15 }
                                                                                        >  4861  
                                                                                        >  4862  // #ifdef UNICODE
                                                                                        >  4863  // #...
                                                                                        >  4864  // #else
                                                                                        >  4865  alias LVN_ODFINDITEMA LVN_ODFINDITEM;
                                                                                        >  4866  // #endif
                                                                                        >  4867  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  4868  
                                                                                        >  4869  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  4870  enum : uint { LVN_HOTTRACK = LVN_FIRST-21 }
                                                                                        >  4871  // #endif
                                                                                        >  4872  
                                                                                        >  4873  enum : uint { LVN_GETDISPINFOA = LVN_FIRST-50 }
                                                                                        >  4874  enum : uint { LVN_GETDISPINFOW = LVN_FIRST-77 }
                                                                                        >  4875  enum : uint { LVN_SETDISPINFOA = LVN_FIRST-51 }
                                                                                        >  4876  enum : uint { LVN_SETDISPINFOW = LVN_FIRST-78 }
                                                                                        >  4877  
                                                                                        >  4878  // #ifdef UNICODE
                                                                                        >  4879  // #...
                                                                                        >  4880  // #...
                                                                                        >  4881  // #...
                                                                                        >  4882  // #...
                                                                                        >  4883  // #else
                                                                                        >  4884  alias LVN_BEGINLABELEDITA LVN_BEGINLABELEDIT;
                                                                                        >  4885  alias LVN_ENDLABELEDITA LVN_ENDLABELEDIT;
                                                                                        >  4886  alias LVN_GETDISPINFOA LVN_GETDISPINFO;
                                                                                        >  4887  alias LVN_SETDISPINFOA LVN_SETDISPINFO;
                                                                                        >  4888  // #endif
                                                                                        >  4889  
                                                                                        >  4890  enum : uint { LVIF_DI_SETITEM = 0x1000 }
                                                                                        >  4891  
                                                                                        >  4892  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4893  alias NMLVDISPINFOA LV_DISPINFOA;
                                                                                        >  4894  alias NMLVDISPINFOW LV_DISPINFOW;
                                                                                        >  4895  // #else
                                                                                        >  4896  // #...
                                                                                        >  4897  // #...
                                                                                        >  4898  // #...
                                                                                        >  4899  // #...
                                                                                        >  4900  // #endif
                                                                                        >  4901  
                                                                                        >  4902  alias NMLVDISPINFO LV_DISPINFO;
                                                                                        >  4903  
                                                                                        >  4904  struct tagLVDISPINFO {
                                                                                        >  4905    NMHDR hdr;
                                                                                        >  4906    LVITEMA item;
                                                                                        >  4907  }
                                                                                        >  4908  alias tagLVDISPINFO NMLVDISPINFOA;
                                                                                        >  4909  alias tagLVDISPINFO* LPNMLVDISPINFOA;
                                                                                        >  4910  
                                                                                        >  4911  struct tagLVDISPINFOW {
                                                                                        >  4912    NMHDR hdr;
                                                                                        >  4913    LVITEMW item;
                                                                                        >  4914  }
                                                                                        >  4915  alias tagLVDISPINFOW NMLVDISPINFOW;
                                                                                        >  4916  alias tagLVDISPINFOW* LPNMLVDISPINFOW;
                                                                                        >  4917  
                                                                                        >  4918  // #ifdef UNICODE
                                                                                        >  4919  // #...
                                                                                        >  4920  // #else
                                                                                        >  4921  alias NMLVDISPINFOA NMLVDISPINFO;
                                                                                        >  4922  // #endif
                                                                                        >  4923  
                                                                                        >  4924  enum : uint { LVN_KEYDOWN = LVN_FIRST-55 }
                                                                                        >  4925  
                                                                                        >  4926  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4927  alias NMLVKEYDOWN LV_KEYDOWN;
                                                                                        >  4928  // #else
                                                                                        >  4929  // #...
                                                                                        >  4930  // #...
                                                                                        >  4931  // #endif
                                                                                        >  4932  
                                                                                        >  4933  // #ifdef _WIN32
                                                                                        >  4934  align(1):
                                                                                        >  4935  // #endif
                                                                                        >  4936  
                                                                                        >  4937  struct tagLVKEYDOWN {
                                                                                        >  4938    NMHDR hdr;
                                                                                        >  4939    WORD wVKey;
                                                                                        >  4940    UINT flags;
                                                                                        >  4941  }
                                                                                        >  4942  alias tagLVKEYDOWN NMLVKEYDOWN;
                                                                                        >  4943  alias tagLVKEYDOWN* LPNMLVKEYDOWN;
                                                                                        >  4944  
                                                                                        >  4945  // #ifdef _WIN32
                                                                                        >  4946  align:
                                                                                        >  4947  // #endif
                                                                                        >  4948  
                                                                                        >  4949  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  4950  enum : uint { LVN_MARQUEEBEGIN = LVN_FIRST-56 }
                                                                                        >  4951  // #endif
                                                                                        >  4952  
                                                                                        >  4953  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  4954  struct tagNMLVGETINFOTIPA {
                                                                                        >  4955    NMHDR hdr;
                                                                                        >  4956    DWORD dwFlags;
                                                                                        >  4957    LPSTR pszText;
                                                                                        >  4958    int cchTextMax;
                                                                                        >  4959    int iItem;
                                                                                        >  4960    int iSubItem;
                                                                                        >  4961    LPARAM lParam;
                                                                                        >  4962  }
                                                                                        >  4963  alias tagNMLVGETINFOTIPA NMLVGETINFOTIPA;
                                                                                        >  4964  alias tagNMLVGETINFOTIPA* LPNMLVGETINFOTIPA;
                                                                                        >  4965  
                                                                                        >  4966  struct tagNMLVGETINFOTIPW {
                                                                                        >  4967    NMHDR hdr;
                                                                                        >  4968    DWORD dwFlags;
                                                                                        >  4969    LPWSTR pszText;
                                                                                        >  4970    int cchTextMax;
                                                                                        >  4971    int iItem;
                                                                                        >  4972    int iSubItem;
                                                                                        >  4973    LPARAM lParam;
                                                                                        >  4974  }
                                                                                        >  4975  alias tagNMLVGETINFOTIPW NMLVGETINFOTIPW;
                                                                                        >  4976  alias tagNMLVGETINFOTIPW* LPNMLVGETINFOTIPW;
                                                                                        >  4977  
                                                                                        >  4978  enum : uint { LVGIT_UNFOLDED = 0x0001 }
                                                                                        >  4979  
                                                                                        >  4980  enum : uint { LVN_GETINFOTIPA = LVN_FIRST-57 }
                                                                                        >  4981  enum : uint { LVN_GETINFOTIPW = LVN_FIRST-58 }
                                                                                        >  4982  
                                                                                        >  4983  // #ifdef UNICODE
                                                                                        >  4984  // #...
                                                                                        >  4985  // #...
                                                                                        >  4986  // #...
                                                                                        >  4987  // #else
                                                                                        >  4988  alias LVN_GETINFOTIPA LVN_GETINFOTIP;
                                                                                        >  4989  alias NMLVGETINFOTIPA NMLVGETINFOTIP;
                                                                                        >  4990  alias LPNMLVGETINFOTIPA LPNMLVGETINFOTIP;
                                                                                        >  4991  // #endif
                                                                                        >  4992  
                                                                                        >  4993  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  4994  
                                                                                        >  4995  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  4996  struct tagNMLVSCROLL {
                                                                                        >  4997    NMHDR hdr;
                                                                                        >  4998    int dx;
                                                                                        >  4999    int dy;
                                                                                        >  5000  }
                                                                                        >  5001  alias tagNMLVSCROLL NMLVSCROLL;
                                                                                        >  5002  alias tagNMLVSCROLL* LPNMLVSCROLL;
                                                                                        >  5003  
                                                                                        >  5004  enum : uint { LVN_BEGINSCROLL = LVN_FIRST-80 }
                                                                                        >  5005  enum : uint { LVN_ENDSCROLL = LVN_FIRST-81 }
                                                                                        >  5006  // #endif
                                                                                        >  5007  
                                                                                        >  5008  // #endif // NOLISTVIEW
                                                                                        >  5009  
                                                                                        >  5010  // #ifndef NOTREEVIEW
                                                                                        >  5011  
                                                                                        >  5012  // #ifdef _WIN32
                                                                                        >  5013  const char[] WC_TREEVIEWA = "SysTreeView32";
                                                                                        >  5014  const wchar[] WC_TREEVIEWW = "SysTreeView32";
                                                                                        >  5015  
                                                                                        >  5016  // #ifdef UNICODE
                                                                                        >  5017  // #...
                                                                                        >  5018  // #else
                                                                                        >  5019  alias WC_TREEVIEWA WC_TREEVIEW;
                                                                                        >  5020  // #endif
                                                                                        >  5021  
                                                                                        >  5022  // #else
                                                                                        >  5023  // #...
                                                                                        >  5024  // #endif
                                                                                        >  5025  
                                                                                        >  5026  enum : uint { TVS_HASBUTTONS = 0x0001 }
                                                                                        >  5027  enum : uint { TVS_HASLINES = 0x0002 }
                                                                                        >  5028  enum : uint { TVS_LINESATROOT = 0x0004 }
                                                                                        >  5029  enum : uint { TVS_EDITLABELS = 0x0008 }
                                                                                        >  5030  enum : uint { TVS_DISABLEDRAGDROP = 0x0010 }
                                                                                        >  5031  enum : uint { TVS_SHOWSELALWAYS = 0x0020 }
                                                                                        >  5032  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5033  enum : uint { TVS_RTLREADING = 0x0040 }
                                                                                        >  5034  
                                                                                        >  5035  enum : uint { TVS_NOTOOLTIPS = 0x0080 }
                                                                                        >  5036  enum : uint { TVS_CHECKBOXES = 0x0100 }
                                                                                        >  5037  enum : uint { TVS_TRACKSELECT = 0x0200 }
                                                                                        >  5038  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5039  enum : uint { TVS_SINGLEEXPAND = 0x0400 }
                                                                                        >  5040  enum : uint { TVS_INFOTIP = 0x0800 }
                                                                                        >  5041  enum : uint { TVS_FULLROWSELECT = 0x1000 }
                                                                                        >  5042  enum : uint { TVS_NOSCROLL = 0x2000 }
                                                                                        >  5043  enum : uint { TVS_NONEVENHEIGHT = 0x4000 }
                                                                                        >  5044  // #endif
                                                                                        >  5045  // #if (_WIN32_IE >= 0x500)
                                                                                        >  5046  enum : uint { TVS_NOHSCROLL = 0x8000 }
                                                                                        >  5047  // #endif
                                                                                        >  5048  // #endif
                                                                                        >  5049  
                                                                                        >  5050  alias _TREEITEM* HTREEITEM;
                                                                                        >  5051  
                                                                                        >  5052  enum : uint { TVIF_TEXT = 0x0001 }
                                                                                        >  5053  enum : uint { TVIF_IMAGE = 0x0002 }
                                                                                        >  5054  enum : uint { TVIF_PARAM = 0x0004 }
                                                                                        >  5055  enum : uint { TVIF_STATE = 0x0008 }
                                                                                        >  5056  enum : uint { TVIF_HANDLE = 0x0010 }
                                                                                        >  5057  enum : uint { TVIF_SELECTEDIMAGE = 0x0020 }
                                                                                        >  5058  enum : uint { TVIF_CHILDREN = 0x0040 }
                                                                                        >  5059  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5060  enum : uint { TVIF_INTEGRAL = 0x0080 }
                                                                                        >  5061  // #endif
                                                                                        >  5062  enum : uint { TVIS_SELECTED = 0x0002 }
                                                                                        >  5063  enum : uint { TVIS_CUT = 0x0004 }
                                                                                        >  5064  enum : uint { TVIS_DROPHILITED = 0x0008 }
                                                                                        >  5065  enum : uint { TVIS_BOLD = 0x0010 }
                                                                                        >  5066  enum : uint { TVIS_EXPANDED = 0x0020 }
                                                                                        >  5067  enum : uint { TVIS_EXPANDEDONCE = 0x0040 }
                                                                                        >  5068  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5069  enum : uint { TVIS_EXPANDPARTIAL = 0x0080 }
                                                                                        >  5070  // #endif
                                                                                        >  5071  
                                                                                        >  5072  enum : uint { TVIS_OVERLAYMASK = 0x0F00 }
                                                                                        >  5073  enum : uint { TVIS_STATEIMAGEMASK = 0xF000 }
                                                                                        >  5074  enum : uint { TVIS_USERMASK = 0xF000 }
                                                                                        >  5075  
                                                                                        >  5076  enum { I_CHILDRENCALLBACK = -1 }
                                                                                        >  5077  
                                                                                        >  5078  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5079  alias LPTVITEMW LPTV_ITEMW;
                                                                                        >  5080  alias LPTVITEMA LPTV_ITEMA;
                                                                                        >  5081  alias TVITEMW TV_ITEMW;
                                                                                        >  5082  alias TVITEMA TV_ITEMA;
                                                                                        >  5083  // #else
                                                                                        >  5084  // #...
                                                                                        >  5085  // #...
                                                                                        >  5086  // #...
                                                                                        >  5087  // #...
                                                                                        >  5088  // #...
                                                                                        >  5089  // #...
                                                                                        >  5090  // #endif
                                                                                        >  5091  
                                                                                        >  5092  alias LPTVITEM LPTV_ITEM;
                                                                                        >  5093  alias TVITEM TV_ITEM;
                                                                                        >  5094  
                                                                                        >  5095  struct tagTVITEMA {
                                                                                        >  5096    UINT mask;
                                                                                        >  5097    HTREEITEM hItem;
                                                                                        >  5098    UINT state;
                                                                                        >  5099    UINT stateMask;
                                                                                        >  5100    LPSTR pszText;
                                                                                        >  5101    int cchTextMax;
                                                                                        >  5102    int iImage;
                                                                                        >  5103    int iSelectedImage;
                                                                                        >  5104    int cChildren;
                                                                                        >  5105    LPARAM lParam;
                                                                                        >  5106  }
                                                                                        >  5107  alias tagTVITEMA TVITEMA;
                                                                                        >  5108  alias tagTVITEMA* LPTVITEMA;
                                                                                        >  5109  
                                                                                        >  5110  struct tagTVITEMW {
                                                                                        >  5111    UINT mask;
                                                                                        >  5112    HTREEITEM hItem;
                                                                                        >  5113    UINT state;
                                                                                        >  5114    UINT stateMask;
                                                                                        >  5115    LPWSTR pszText;
                                                                                        >  5116    int cchTextMax;
                                                                                        >  5117    int iImage;
                                                                                        >  5118    int iSelectedImage;
                                                                                        >  5119    int cChildren;
                                                                                        >  5120    LPARAM lParam;
                                                                                        >  5121  }
                                                                                        >  5122  alias tagTVITEMW TVITEMW;
                                                                                        >  5123  alias tagTVITEMW* LPTVITEMW;
                                                                                        >  5124  
                                                                                        >  5125  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5126  
                                                                                        >  5127  struct tagTVITEMEXA {
                                                                                        >  5128    UINT mask;
                                                                                        >  5129    HTREEITEM hItem;
                                                                                        >  5130    UINT state;
                                                                                        >  5131    UINT stateMask;
                                                                                        >  5132    LPSTR pszText;
                                                                                        >  5133    int cchTextMax;
                                                                                        >  5134    int iImage;
                                                                                        >  5135    int iSelectedImage;
                                                                                        >  5136    int cChildren;
                                                                                        >  5137    LPARAM lParam;
                                                                                        >  5138    int iIntegral;
                                                                                        >  5139  }
                                                                                        >  5140  alias tagTVITEMEXA TVITEMEXA;
                                                                                        >  5141  alias tagTVITEMEXA* LPTVITEMEXA;
                                                                                        >  5142  
                                                                                        >  5143  struct tagTVITEMEXW {
                                                                                        >  5144    UINT mask;
                                                                                        >  5145    HTREEITEM hItem;
                                                                                        >  5146    UINT state;
                                                                                        >  5147    UINT stateMask;
                                                                                        >  5148    LPWSTR pszText;
                                                                                        >  5149    int cchTextMax;
                                                                                        >  5150    int iImage;
                                                                                        >  5151    int iSelectedImage;
                                                                                        >  5152    int cChildren;
                                                                                        >  5153    LPARAM lParam;
                                                                                        >  5154    int iIntegral;
                                                                                        >  5155  }
                                                                                        >  5156  alias tagTVITEMEXW TVITEMEXW;
                                                                                        >  5157  alias tagTVITEMEXW* LPTVITEMEXW;
                                                                                        >  5158  
                                                                                        >  5159  // #ifdef UNICODE
                                                                                        >  5160  // ...
                                                                                        >  5161  // #else
                                                                                        >  5162  alias TVITEMEXA TVITEMEX;
                                                                                        >  5163  alias LPTVITEMEXA LPTVITEMEX;
                                                                                        >  5164  // #endif // UNICODE
                                                                                        >  5165  
                                                                                        >  5166  // #endif
                                                                                        >  5167  
                                                                                        >  5168  // #ifdef UNICODE
                                                                                        >  5169  // #...
                                                                                        >  5170  // #...
                                                                                        >  5171  // #else
                                                                                        >  5172  alias TVITEMA TVITEM;
                                                                                        >  5173  alias LPTVITEMA LPTVITEM;
                                                                                        >  5174  // #endif
                                                                                        >  5175  
                                                                                        >  5176  const HTREEITEM TVI_ROOT = cast(HTREEITEM)(-0x10000);
                                                                                        >  5177  const HTREEITEM TVI_FIRST = cast(HTREEITEM)(-0x0FFFF);
                                                                                        >  5178  const HTREEITEM TVI_LAST = cast(HTREEITEM)(-0x0FFFE);
                                                                                        >  5179  const HTREEITEM TVI_SORT = cast(HTREEITEM)(-0x0FFFD);
                                                                                        >  5180  
                                                                                        >  5181  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5182  alias LPTVINSERTSTRUCTA LPTV_INSERTSTRUCTA;
                                                                                        >  5183  alias LPTVINSERTSTRUCTW LPTV_INSERTSTRUCTW;
                                                                                        >  5184  alias TVINSERTSTRUCTA TV_INSERTSTRUCTA;
                                                                                        >  5185  alias TVINSERTSTRUCTW TV_INSERTSTRUCTW;
                                                                                        >  5186  // #else
                                                                                        >  5187  // #...
                                                                                        >  5188  // #...
                                                                                        >  5189  // #...
                                                                                        >  5190  // #...
                                                                                        >  5191  // #...
                                                                                        >  5192  // #...
                                                                                        >  5193  // #endif
                                                                                        >  5194  
                                                                                        >  5195  alias TVINSERTSTRUCT TV_INSERTSTRUCT;
                                                                                        >  5196  alias LPTVINSERTSTRUCT LPTV_INSERTSTRUCT;
                                                                                        >  5197  
                                                                                        >  5198  // #define TVINSERTSTRUCTA_V1_SIZE CCSIZEOF_STRUCT(TVINSERTSTRUCTA, item)
                                                                                        >  5199  // #define TVINSERTSTRUCTW_V1_SIZE CCSIZEOF_STRUCT(TVINSERTSTRUCTW, item)
                                                                                        >  5200  
                                                                                        >  5201  struct tagTVINSERTSTRUCTA {
                                                                                        >  5202    HTREEITEM hParent;
                                                                                        >  5203    HTREEITEM hInsertAfter;
                                                                                        >  5204  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5205  union {
                                                                                        >  5206    TVITEMEXA itemex;
                                                                                        >  5207    TV_ITEMA item;
                                                                                        >  5208  }
                                                                                        >  5209  
                                                                                        >  5210  // #else
                                                                                        >  5211  // ...
                                                                                        >  5212  // #endif
                                                                                        >  5213  }
                                                                                        >  5214  alias tagTVINSERTSTRUCTA TVINSERTSTRUCTA;
                                                                                        >  5215  alias tagTVINSERTSTRUCTA* LPTVINSERTSTRUCTA;
                                                                                        >  5216  
                                                                                        >  5217  struct tagTVINSERTSTRUCTW {
                                                                                        >  5218    HTREEITEM hParent;
                                                                                        >  5219    HTREEITEM hInsertAfter;
                                                                                        >  5220  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5221  union {
                                                                                        >  5222    TVITEMEXW itemex;
                                                                                        >  5223    TV_ITEMW item;
                                                                                        >  5224  }
                                                                                        >  5225  
                                                                                        >  5226  // #else
                                                                                        >  5227  // ...
                                                                                        >  5228  // #endif
                                                                                        >  5229  }
                                                                                        >  5230  alias tagTVINSERTSTRUCTW TVINSERTSTRUCTW;
                                                                                        >  5231  alias tagTVINSERTSTRUCTW* LPTVINSERTSTRUCTW;
                                                                                        >  5232  
                                                                                        >  5233  // #ifdef UNICODE
                                                                                        >  5234  // #...
                                                                                        >  5235  // #...
                                                                                        >  5236  // #...
                                                                                        >  5237  // #else
                                                                                        >  5238  alias TVINSERTSTRUCTA TVINSERTSTRUCT;
                                                                                        >  5239  alias LPTVINSERTSTRUCTA LPTVINSERTSTRUCT;
                                                                                        >  5240  // #define TVINSERTSTRUCT_V1_SIZE TVINSERTSTRUCTA_V1_SIZE
                                                                                        >  5241  // #endif
                                                                                        >  5242  
                                                                                        >  5243  enum : uint { TVM_INSERTITEMA = TV_FIRST + 0 }
                                                                                        >  5244  enum : uint { TVM_INSERTITEMW = TV_FIRST + 50 }
                                                                                        >  5245  // #ifdef UNICODE
                                                                                        >  5246  // #...
                                                                                        >  5247  // #else
                                                                                        >  5248  alias TVM_INSERTITEMA TVM_INSERTITEM;
                                                                                        >  5249  // #endif
                                                                                        >  5250  
                                                                                        >  5251  // #define TreeView_InsertItem(hwnd, lpis) (HTREEITEM)SNDMSG((hwnd), TVM_INSERTI
                                                                                        >  5252  
                                                                                        >  5253  enum : uint { TVM_DELETEITEM = TV_FIRST + 1 }
                                                                                        >  5254  // #define TreeView_DeleteItem(hwnd, hitem) (BOOL)SNDMSG((hwnd), TVM_DELETEITEM,
                                                                                        >  5255  
                                                                                        >  5256  // #define TreeView_DeleteAllItems(hwnd) (BOOL)SNDMSG((hwnd), TVM_DELETEITEM, 0,
                                                                                        >  5257  
                                                                                        >  5258  enum : uint { TVM_EXPAND = TV_FIRST + 2 }
                                                                                        >  5259  // #define TreeView_Expand(hwnd, hitem, code) (BOOL)SNDMSG((hwnd), TVM_EXPAND, (
                                                                                        >  5260  
                                                                                        >  5261  enum : uint { TVE_COLLAPSE = 0x0001 }
                                                                                        >  5262  enum : uint { TVE_EXPAND = 0x0002 }
                                                                                        >  5263  enum : uint { TVE_TOGGLE = 0x0003 }
                                                                                        >  5264  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5265  enum : uint { TVE_EXPANDPARTIAL = 0x4000 }
                                                                                        >  5266  // #endif
                                                                                        >  5267  enum : uint { TVE_COLLAPSERESET = 0x8000 }
                                                                                        >  5268  
                                                                                        >  5269  enum : uint { TVM_GETITEMRECT = TV_FIRST + 4 }
                                                                                        >  5270  // #define TreeView_GetItemRect(hwnd, hitem, prc, code) (*(HTREEITEM *)prc = (hi
                                                                                        >  5271  
                                                                                        >  5272  enum : uint { TVM_GETCOUNT = TV_FIRST + 5 }
                                                                                        >  5273  // #define TreeView_GetCount(hwnd) (UINT)SNDMSG((hwnd), TVM_GETCOUNT, 0, 0)
                                                                                        >  5274  
                                                                                        >  5275  enum : uint { TVM_GETINDENT = TV_FIRST + 6 }
                                                                                        >  5276  // #define TreeView_GetIndent(hwnd) (UINT)SNDMSG((hwnd), TVM_GETINDENT, 0, 0)
                                                                                        >  5277  
                                                                                        >  5278  enum : uint { TVM_SETINDENT = TV_FIRST + 7 }
                                                                                        >  5279  // #define TreeView_SetIndent(hwnd, indent) (BOOL)SNDMSG((hwnd), TVM_SETINDENT, 
                                                                                        >  5280  
                                                                                        >  5281  enum : uint { TVM_GETIMAGELIST = TV_FIRST + 8 }
                                                                                        >  5282  // #define TreeView_GetImageList(hwnd, iImage) (HIMAGELIST)SNDMSG((hwnd), TVM_GE
                                                                                        >  5283  
                                                                                        >  5284  enum : uint { TVSIL_NORMAL = 0 }
                                                                                        >  5285  enum : uint { TVSIL_STATE = 2 }
                                                                                        >  5286  
                                                                                        >  5287  enum : uint { TVM_SETIMAGELIST = TV_FIRST + 9 }
                                                                                        >  5288  // #define TreeView_SetImageList(hwnd, himl, iImage) (HIMAGELIST)SNDMSG((hwnd), 
                                                                                        >  5289  
                                                                                        >  5290  enum : uint { TVM_GETNEXTITEM = TV_FIRST + 10 }
                                                                                        >  5291  // #define TreeView_GetNextItem(hwnd, hitem, code) (HTREEITEM)SNDMSG((hwnd), TVM
                                                                                        >  5292  
                                                                                        >  5293  enum : uint { TVGN_ROOT = 0x0000 }
                                                                                        >  5294  enum : uint { TVGN_NEXT = 0x0001 }
                                                                                        >  5295  enum : uint { TVGN_PREVIOUS = 0x0002 }
                                                                                        >  5296  enum : uint { TVGN_PARENT = 0x0003 }
                                                                                        >  5297  enum : uint { TVGN_CHILD = 0x0004 }
                                                                                        >  5298  enum : uint { TVGN_FIRSTVISIBLE = 0x0005 }
                                                                                        >  5299  enum : uint { TVGN_NEXTVISIBLE = 0x0006 }
                                                                                        >  5300  enum : uint { TVGN_PREVIOUSVISIBLE = 0x0007 }
                                                                                        >  5301  enum : uint { TVGN_DROPHILITE = 0x0008 }
                                                                                        >  5302  enum : uint { TVGN_CARET = 0x0009 }
                                                                                        >  5303  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5304  enum : uint { TVGN_LASTVISIBLE = 0x000A }
                                                                                        >  5305  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  5306  
                                                                                        >  5307  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  5308  enum : uint { TVSI_NOSINGLEEXPAND = 0x8000 }
                                                                                        >  5309  // #endif
                                                                                        >  5310  
                                                                                        >  5311  // #define TreeView_GetChild(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem, TVGN
                                                                                        >  5312  // #define TreeView_GetNextSibling(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem
                                                                                        >  5313  // #define TreeView_GetPrevSibling(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem
                                                                                        >  5314  // #define TreeView_GetParent(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem, TVG
                                                                                        >  5315  // #define TreeView_GetFirstVisible(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_
                                                                                        >  5316  // #define TreeView_GetNextVisible(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem
                                                                                        >  5317  // #define TreeView_GetPrevVisible(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem
                                                                                        >  5318  // #define TreeView_GetSelection(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_CAR
                                                                                        >  5319  // #define TreeView_GetDropHilight(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_D
                                                                                        >  5320  // #define TreeView_GetRoot(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_ROOT)
                                                                                        >  5321  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5322  // #define TreeView_GetLastVisible(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_L
                                                                                        >  5323  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  5324  
                                                                                        >  5325  enum : uint { TVM_SELECTITEM = TV_FIRST + 11 }
                                                                                        >  5326  // #define TreeView_Select(hwnd, hitem, code) (BOOL)SNDMSG((hwnd), TVM_SELECTITE
                                                                                        >  5327  
                                                                                        >  5328  // #define TreeView_SelectItem(hwnd, hitem) TreeView_Select(hwnd, hitem, TVGN_CA
                                                                                        >  5329  // #define TreeView_SelectDropTarget(hwnd, hitem) TreeView_Select(hwnd, hitem, T
                                                                                        >  5330  // #define TreeView_SelectSetFirstVisible(hwnd, hitem) TreeView_Select(hwnd, hit
                                                                                        >  5331  
                                                                                        >  5332  enum : uint { TVM_GETITEMA = TV_FIRST + 12 }
                                                                                        >  5333  enum : uint { TVM_GETITEMW = TV_FIRST + 62 }
                                                                                        >  5334  
                                                                                        >  5335  // #ifdef UNICODE
                                                                                        >  5336  // #...
                                                                                        >  5337  // #else
                                                                                        >  5338  alias TVM_GETITEMA TVM_GETITEM;
                                                                                        >  5339  // #endif
                                                                                        >  5340  
                                                                                        >  5341  // #define TreeView_GetItem(hwnd, pitem) (BOOL)SNDMSG((hwnd), TVM_GETITEM, 0, (L
                                                                                        >  5342  
                                                                                        >  5343  enum : uint { TVM_SETITEMA = TV_FIRST + 13 }
                                                                                        >  5344  enum : uint { TVM_SETITEMW = TV_FIRST + 63 }
                                                                                        >  5345  
                                                                                        >  5346  // #ifdef UNICODE
                                                                                        >  5347  // #...
                                                                                        >  5348  // #else
                                                                                        >  5349  alias TVM_SETITEMA TVM_SETITEM;
                                                                                        >  5350  // #endif
                                                                                        >  5351  
                                                                                        >  5352  // #define TreeView_SetItem(hwnd, pitem) (BOOL)SNDMSG((hwnd), TVM_SETITEM, 0, (L
                                                                                        >  5353  
                                                                                        >  5354  enum : uint { TVM_EDITLABELA = TV_FIRST + 14 }
                                                                                        >  5355  enum : uint { TVM_EDITLABELW = TV_FIRST + 65 }
                                                                                        >  5356  // #ifdef UNICODE
                                                                                        >  5357  // #...
                                                                                        >  5358  // #else
                                                                                        >  5359  alias TVM_EDITLABELA TVM_EDITLABEL;
                                                                                        >  5360  // #endif
                                                                                        >  5361  
                                                                                        >  5362  // #define TreeView_EditLabel(hwnd, hitem) (HWND)SNDMSG((hwnd), TVM_EDITLABEL, 0
                                                                                        >  5363  
                                                                                        >  5364  enum : uint { TVM_GETEDITCONTROL = TV_FIRST + 15 }
                                                                                        >  5365  // #define TreeView_GetEditControl(hwnd) (HWND)SNDMSG((hwnd), TVM_GETEDITCONTROL
                                                                                        >  5366  
                                                                                        >  5367  enum : uint { TVM_GETVISIBLECOUNT = TV_FIRST + 16 }
                                                                                        >  5368  // #define TreeView_GetVisibleCount(hwnd) (UINT)SNDMSG((hwnd), TVM_GETVISIBLECOU
                                                                                        >  5369  
                                                                                        >  5370  enum : uint { TVM_HITTEST = TV_FIRST + 17 }
                                                                                        >  5371  // #define TreeView_HitTest(hwnd, lpht) (HTREEITEM)SNDMSG((hwnd), TVM_HITTEST, 0
                                                                                        >  5372  
                                                                                        >  5373  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5374  alias LPTVHITTESTINFO LPTV_HITTESTINFO;
                                                                                        >  5375  alias TVHITTESTINFO TV_HITTESTINFO;
                                                                                        >  5376  // #else
                                                                                        >  5377  // #...
                                                                                        >  5378  // #...
                                                                                        >  5379  // #...
                                                                                        >  5380  // #endif
                                                                                        >  5381  
                                                                                        >  5382  struct tagTVHITTESTINFO {
                                                                                        >  5383    POINT pt;
                                                                                        >  5384    UINT flags;
                                                                                        >  5385    HTREEITEM hItem;
                                                                                        >  5386  }
                                                                                        >  5387  alias tagTVHITTESTINFO TVHITTESTINFO;
                                                                                        >  5388  alias tagTVHITTESTINFO* LPTVHITTESTINFO;
                                                                                        >  5389  
                                                                                        >  5390  enum : uint { TVHT_NOWHERE = 0x0001 }
                                                                                        >  5391  enum : uint { TVHT_ONITEMICON = 0x0002 }
                                                                                        >  5392  enum : uint { TVHT_ONITEMLABEL = 0x0004 }
                                                                                        >  5393  enum : uint { TVHT_ONITEM = TVHT_ONITEMICON | TVHT_ONITEMLABEL | TVHT_ONITEMSTAT
                                                                                        >  5394  enum : uint { TVHT_ONITEMINDENT = 0x0008 }
                                                                                        >  5395  enum : uint { TVHT_ONITEMBUTTON = 0x0010 }
                                                                                        >  5396  enum : uint { TVHT_ONITEMRIGHT = 0x0020 }
                                                                                        >  5397  // #define TVHT_ONITEMSTATEICON 0x0040
                                                                                        >  5398  
                                                                                        >  5399  enum : uint { TVHT_ABOVE = 0x0100 }
                                                                                        >  5400  enum : uint { TVHT_BELOW = 0x0200 }
                                                                                        >  5401  enum : uint { TVHT_TORIGHT = 0x0400 }
                                                                                        >  5402  enum : uint { TVHT_TOLEFT = 0x0800 }
                                                                                        >  5403  
                                                                                        >  5404  enum : uint { TVM_CREATEDRAGIMAGE = TV_FIRST + 18 }
                                                                                        >  5405  // #define TreeView_CreateDragImage(hwnd, hitem) (HIMAGELIST)SNDMSG((hwnd), TVM_
                                                                                        >  5406  
                                                                                        >  5407  enum : uint { TVM_SORTCHILDREN = TV_FIRST + 19 }
                                                                                        >  5408  // #define TreeView_SortChildren(hwnd, hitem, recurse) (BOOL)SNDMSG((hwnd), TVM_
                                                                                        >  5409  
                                                                                        >  5410  enum : uint { TVM_ENSUREVISIBLE = TV_FIRST + 20 }
                                                                                        >  5411  // #define TreeView_EnsureVisible(hwnd, hitem) (BOOL)SNDMSG((hwnd), TVM_ENSUREVI
                                                                                        >  5412  
                                                                                        >  5413  enum : uint { TVM_SORTCHILDRENCB = TV_FIRST + 21 }
                                                                                        >  5414  // #define TreeView_SortChildrenCB(hwnd, psort, recurse) (BOOL)SNDMSG((hwnd), TV
                                                                                        >  5415  
                                                                                        >  5416  enum : uint { TVM_ENDEDITLABELNOW = TV_FIRST + 22 }
                                                                                        >  5417  // #define TreeView_EndEditLabelNow(hwnd, fCancel) (BOOL)SNDMSG((hwnd), TVM_ENDE
                                                                                        >  5418  
                                                                                        >  5419  enum : uint { TVM_GETISEARCHSTRINGA = TV_FIRST + 23 }
                                                                                        >  5420  enum : uint { TVM_GETISEARCHSTRINGW = TV_FIRST + 64 }
                                                                                        >  5421  
                                                                                        >  5422  // #ifdef UNICODE
                                                                                        >  5423  // #...
                                                                                        >  5424  // #else
                                                                                        >  5425  alias TVM_GETISEARCHSTRINGA TVM_GETISEARCHSTRING;
                                                                                        >  5426  // #endif
                                                                                        >  5427  
                                                                                        >  5428  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5429  enum : uint { TVM_SETTOOLTIPS = TV_FIRST + 24 }
                                                                                        >  5430  // #define TreeView_SetToolTips(hwnd, hwndTT) (HWND)SNDMSG((hwnd), TVM_SETTOOLTI
                                                                                        >  5431  enum : uint { TVM_GETTOOLTIPS = TV_FIRST + 25 }
                                                                                        >  5432  // #define TreeView_GetToolTips(hwnd) (HWND)SNDMSG((hwnd), TVM_GETTOOLTIPS, 0, 0
                                                                                        >  5433  // #endif
                                                                                        >  5434  
                                                                                        >  5435  // #define TreeView_GetISearchString(hwndTV, lpsz) (BOOL)SNDMSG((hwndTV), TVM_GE
                                                                                        >  5436  
                                                                                        >  5437  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5438  enum : uint { TVM_SETINSERTMARK = TV_FIRST + 26 }
                                                                                        >  5439  // #define TreeView_SetInsertMark(hwnd, hItem, fAfter) (BOOL)SNDMSG((hwnd), TVM_
                                                                                        >  5440  
                                                                                        >  5441  alias CCM_SETUNICODEFORMAT TVM_SETUNICODEFORMAT;
                                                                                        >  5442  // #define TreeView_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), TVM_SE
                                                                                        >  5443  
                                                                                        >  5444  alias CCM_GETUNICODEFORMAT TVM_GETUNICODEFORMAT;
                                                                                        >  5445  // #define TreeView_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), TVM_GETUNICODEFO
                                                                                        >  5446  
                                                                                        >  5447  // #endif
                                                                                        >  5448  
                                                                                        >  5449  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5450  enum : uint { TVM_SETITEMHEIGHT = TV_FIRST + 27 }
                                                                                        >  5451  // #define TreeView_SetItemHeight(hwnd, iHeight) (int)SNDMSG((hwnd), TVM_SETITEM
                                                                                        >  5452  enum : uint { TVM_GETITEMHEIGHT = TV_FIRST + 28 }
                                                                                        >  5453  // #define TreeView_GetItemHeight(hwnd) (int)SNDMSG((hwnd), TVM_GETITEMHEIGHT, 0
                                                                                        >  5454  
                                                                                        >  5455  enum : uint { TVM_SETBKCOLOR = TV_FIRST + 29 }
                                                                                        >  5456  // #define TreeView_SetBkColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_SETBKCOLO
                                                                                        >  5457  
                                                                                        >  5458  enum : uint { TVM_SETTEXTCOLOR = TV_FIRST + 30 }
                                                                                        >  5459  // #define TreeView_SetTextColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_SETTEXT
                                                                                        >  5460  
                                                                                        >  5461  enum : uint { TVM_GETBKCOLOR = TV_FIRST + 31 }
                                                                                        >  5462  // #define TreeView_GetBkColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETBKCOLOR, 0,
                                                                                        >  5463  
                                                                                        >  5464  enum : uint { TVM_GETTEXTCOLOR = TV_FIRST + 32 }
                                                                                        >  5465  // #define TreeView_GetTextColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETTEXTCOLOR
                                                                                        >  5466  
                                                                                        >  5467  enum : uint { TVM_SETSCROLLTIME = TV_FIRST + 33 }
                                                                                        >  5468  // #define TreeView_SetScrollTime(hwnd, uTime) (UINT)SNDMSG((hwnd), TVM_SETSCROL
                                                                                        >  5469  
                                                                                        >  5470  enum : uint { TVM_GETSCROLLTIME = TV_FIRST + 34 }
                                                                                        >  5471  // #define TreeView_GetScrollTime(hwnd) (UINT)SNDMSG((hwnd), TVM_GETSCROLLTIME, 
                                                                                        >  5472  
                                                                                        >  5473  enum : uint { TVM_SETINSERTMARKCOLOR = TV_FIRST + 37 }
                                                                                        >  5474  // #define TreeView_SetInsertMarkColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_S
                                                                                        >  5475  enum : uint { TVM_GETINSERTMARKCOLOR = TV_FIRST + 38 }
                                                                                        >  5476  // #define TreeView_GetInsertMarkColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETINS
                                                                                        >  5477  
                                                                                        >  5478  // #endif  /* (_WIN32_IE >= 0x0400) */
                                                                                        >  5479  
                                                                                        >  5480  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  5481  
                                                                                        >  5482  // #define TreeView_SetItemState(hwndTV, hti, data, _mask) { TVITEM _ms_TVi; _ms
                                                                                        >  5483  
                                                                                        >  5484  // #define TreeView_SetCheckState(hwndTV, hti, fCheck) TreeView_SetItemState(hwn
                                                                                        >  5485  
                                                                                        >  5486  enum : uint { TVM_GETITEMSTATE = TV_FIRST + 39 }
                                                                                        >  5487  // #define TreeView_GetItemState(hwndTV, hti, mask) (UINT)SNDMSG((hwndTV), TVM_G
                                                                                        >  5488  
                                                                                        >  5489  // #define TreeView_GetCheckState(hwndTV, hti) ((((UINT)(SNDMSG((hwndTV), TVM_GE
                                                                                        >  5490  
                                                                                        >  5491  enum : uint { TVM_SETLINECOLOR = TV_FIRST + 40 }
                                                                                        >  5492  // #define TreeView_SetLineColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_SETLINE
                                                                                        >  5493  
                                                                                        >  5494  enum : uint { TVM_GETLINECOLOR = TV_FIRST + 41 }
                                                                                        >  5495  // #define TreeView_GetLineColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETLINECOLOR
                                                                                        >  5496  
                                                                                        >  5497  // #endif
                                                                                        >  5498  
                                                                                        >  5499  // #if (_WIN32_WINNT >= 0x0501)
                                                                                        >  5500  enum : uint { TVM_MAPACCIDTOHTREEITEM = TV_FIRST + 42 }
                                                                                        >  5501  // #define TreeView_MapAccIDToHTREEITEM(hwnd, id) (HTREEITEM)SNDMSG((hwnd), TVM_
                                                                                        >  5502  
                                                                                        >  5503  enum : uint { TVM_MAPHTREEITEMTOACCID = TV_FIRST + 43 }
                                                                                        >  5504  // #define TreeView_MapHTREEITEMToAccID(hwnd, htreeitem) (UINT)SNDMSG((hwnd), TV
                                                                                        >  5505  
                                                                                        >  5506  // #endif
                                                                                        >  5507  
                                                                                        >  5508  extern(Windows) alias int function(LPARAM lParam1, LPARAM lParam2, LPARAM lParam
                                                                                        >  5509  
                                                                                        >  5510  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5511  alias LPTVSORTCB LPTV_SORTCB;
                                                                                        >  5512  alias TVSORTCB TV_SORTCB;
                                                                                        >  5513  // #else
                                                                                        >  5514  // #...
                                                                                        >  5515  // #...
                                                                                        >  5516  // #...
                                                                                        >  5517  // #endif
                                                                                        >  5518  
                                                                                        >  5519  struct tagTVSORTCB {
                                                                                        >  5520    HTREEITEM hParent;
                                                                                        >  5521    PFNTVCOMPARE lpfnCompare;
                                                                                        >  5522    LPARAM lParam;
                                                                                        >  5523  }
                                                                                        >  5524  alias tagTVSORTCB TVSORTCB;
                                                                                        >  5525  alias tagTVSORTCB* LPTVSORTCB;
                                                                                        >  5526  
                                                                                        >  5527  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5528  alias LPNMTREEVIEWA LPNM_TREEVIEWA;
                                                                                        >  5529  alias LPNMTREEVIEWW LPNM_TREEVIEWW;
                                                                                        >  5530  alias NMTREEVIEWW NM_TREEVIEWW;
                                                                                        >  5531  alias NMTREEVIEWA NM_TREEVIEWA;
                                                                                        >  5532  // #else
                                                                                        >  5533  // #...
                                                                                        >  5534  // #...
                                                                                        >  5535  // #...
                                                                                        >  5536  // #...
                                                                                        >  5537  // #...
                                                                                        >  5538  // #...
                                                                                        >  5539  // #endif
                                                                                        >  5540  
                                                                                        >  5541  alias LPNMTREEVIEW LPNM_TREEVIEW;
                                                                                        >  5542  alias NMTREEVIEW NM_TREEVIEW;
                                                                                        >  5543  
                                                                                        >  5544  struct tagNMTREEVIEWA {
                                                                                        >  5545    NMHDR hdr;
                                                                                        >  5546    UINT action;
                                                                                        >  5547    TVITEMA itemOld;
                                                                                        >  5548    TVITEMA itemNew;
                                                                                        >  5549    POINT ptDrag;
                                                                                        >  5550  }
                                                                                        >  5551  alias tagNMTREEVIEWA NMTREEVIEWA;
                                                                                        >  5552  alias tagNMTREEVIEWA* LPNMTREEVIEWA;
                                                                                        >  5553  
                                                                                        >  5554  struct tagNMTREEVIEWW {
                                                                                        >  5555    NMHDR hdr;
                                                                                        >  5556    UINT action;
                                                                                        >  5557    TVITEMW itemOld;
                                                                                        >  5558    TVITEMW itemNew;
                                                                                        >  5559    POINT ptDrag;
                                                                                        >  5560  }
                                                                                        >  5561  alias tagNMTREEVIEWW NMTREEVIEWW;
                                                                                        >  5562  alias tagNMTREEVIEWW* LPNMTREEVIEWW;
                                                                                        >  5563  
                                                                                        >  5564  // #ifdef UNICODE
                                                                                        >  5565  // #...
                                                                                        >  5566  // #...
                                                                                        >  5567  // #else
                                                                                        >  5568  alias NMTREEVIEWA NMTREEVIEW;
                                                                                        >  5569  alias LPNMTREEVIEWA LPNMTREEVIEW;
                                                                                        >  5570  // #endif
                                                                                        >  5571  
                                                                                        >  5572  enum : uint { TVN_SELCHANGINGA = TVN_FIRST-1 }
                                                                                        >  5573  enum : uint { TVN_SELCHANGINGW = TVN_FIRST-50 }
                                                                                        >  5574  enum : uint { TVN_SELCHANGEDA = TVN_FIRST-2 }
                                                                                        >  5575  enum : uint { TVN_SELCHANGEDW = TVN_FIRST-51 }
                                                                                        >  5576  
                                                                                        >  5577  enum : uint { TVC_UNKNOWN = 0x0000 }
                                                                                        >  5578  enum : uint { TVC_BYMOUSE = 0x0001 }
                                                                                        >  5579  enum : uint { TVC_BYKEYBOARD = 0x0002 }
                                                                                        >  5580  
                                                                                        >  5581  enum : uint { TVN_GETDISPINFOA = TVN_FIRST-3 }
                                                                                        >  5582  enum : uint { TVN_GETDISPINFOW = TVN_FIRST-52 }
                                                                                        >  5583  enum : uint { TVN_SETDISPINFOA = TVN_FIRST-4 }
                                                                                        >  5584  enum : uint { TVN_SETDISPINFOW = TVN_FIRST-53 }
                                                                                        >  5585  
                                                                                        >  5586  enum : uint { TVIF_DI_SETITEM = 0x1000 }
                                                                                        >  5587  
                                                                                        >  5588  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5589  alias NMTVDISPINFOA TV_DISPINFOA;
                                                                                        >  5590  alias NMTVDISPINFOW TV_DISPINFOW;
                                                                                        >  5591  // #else
                                                                                        >  5592  // #...
                                                                                        >  5593  // #...
                                                                                        >  5594  // #...
                                                                                        >  5595  // #...
                                                                                        >  5596  // #endif
                                                                                        >  5597  
                                                                                        >  5598  alias NMTVDISPINFO TV_DISPINFO;
                                                                                        >  5599  
                                                                                        >  5600  struct tagTVDISPINFOA {
                                                                                        >  5601    NMHDR hdr;
                                                                                        >  5602    TVITEMA item;
                                                                                        >  5603  }
                                                                                        >  5604  alias tagTVDISPINFOA NMTVDISPINFOA;
                                                                                        >  5605  alias tagTVDISPINFOA* LPNMTVDISPINFOA;
                                                                                        >  5606  
                                                                                        >  5607  struct tagTVDISPINFOW {
                                                                                        >  5608    NMHDR hdr;
                                                                                        >  5609    TVITEMW item;
                                                                                        >  5610  }
                                                                                        >  5611  alias tagTVDISPINFOW NMTVDISPINFOW;
                                                                                        >  5612  alias tagTVDISPINFOW* LPNMTVDISPINFOW;
                                                                                        >  5613  
                                                                                        >  5614  // #ifdef UNICODE
                                                                                        >  5615  // #...
                                                                                        >  5616  // #...
                                                                                        >  5617  // #else
                                                                                        >  5618  alias NMTVDISPINFOA NMTVDISPINFO;
                                                                                        >  5619  alias LPNMTVDISPINFOA LPNMTVDISPINFO;
                                                                                        >  5620  // #endif
                                                                                        >  5621  
                                                                                        >  5622  enum : uint { TVN_ITEMEXPANDINGA = TVN_FIRST-5 }
                                                                                        >  5623  enum : uint { TVN_ITEMEXPANDINGW = TVN_FIRST-54 }
                                                                                        >  5624  enum : uint { TVN_ITEMEXPANDEDA = TVN_FIRST-6 }
                                                                                        >  5625  enum : uint { TVN_ITEMEXPANDEDW = TVN_FIRST-55 }
                                                                                        >  5626  enum : uint { TVN_BEGINDRAGA = TVN_FIRST-7 }
                                                                                        >  5627  enum : uint { TVN_BEGINDRAGW = TVN_FIRST-56 }
                                                                                        >  5628  enum : uint { TVN_BEGINRDRAGA = TVN_FIRST-8 }
                                                                                        >  5629  enum : uint { TVN_BEGINRDRAGW = TVN_FIRST-57 }
                                                                                        >  5630  enum : uint { TVN_DELETEITEMA = TVN_FIRST-9 }
                                                                                        >  5631  enum : uint { TVN_DELETEITEMW = TVN_FIRST-58 }
                                                                                        >  5632  enum : uint { TVN_BEGINLABELEDITA = TVN_FIRST-10 }
                                                                                        >  5633  enum : uint { TVN_BEGINLABELEDITW = TVN_FIRST-59 }
                                                                                        >  5634  enum : uint { TVN_ENDLABELEDITA = TVN_FIRST-11 }
                                                                                        >  5635  enum : uint { TVN_ENDLABELEDITW = TVN_FIRST-60 }
                                                                                        >  5636  enum : uint { TVN_KEYDOWN = TVN_FIRST-12 }
                                                                                        >  5637  
                                                                                        >  5638  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5639  enum : uint { TVN_GETINFOTIPA = TVN_FIRST-13 }
                                                                                        >  5640  enum : uint { TVN_GETINFOTIPW = TVN_FIRST-14 }
                                                                                        >  5641  enum : uint { TVN_SINGLEEXPAND = TVN_FIRST-15 }
                                                                                        >  5642  
                                                                                        >  5643  enum : uint { TVNRET_DEFAULT = 0 }
                                                                                        >  5644  enum : uint { TVNRET_SKIPOLD = 1 }
                                                                                        >  5645  enum : uint { TVNRET_SKIPNEW = 2 }
                                                                                        >  5646  
                                                                                        >  5647  // #endif // 0x400
                                                                                        >  5648  
                                                                                        >  5649  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5650  alias NMTVKEYDOWN TV_KEYDOWN;
                                                                                        >  5651  // #else
                                                                                        >  5652  // #...
                                                                                        >  5653  // #...
                                                                                        >  5654  // #endif
                                                                                        >  5655  
                                                                                        >  5656  // #ifdef _WIN32
                                                                                        >  5657  align(1):
                                                                                        >  5658  // #endif
                                                                                        >  5659  
                                                                                        >  5660  struct tagTVKEYDOWN {
                                                                                        >  5661    NMHDR hdr;
                                                                                        >  5662    WORD wVKey;
                                                                                        >  5663    UINT flags;
                                                                                        >  5664  }
                                                                                        >  5665  alias tagTVKEYDOWN NMTVKEYDOWN;
                                                                                        >  5666  alias tagTVKEYDOWN* LPNMTVKEYDOWN;
                                                                                        >  5667  
                                                                                        >  5668  // #ifdef _WIN32
                                                                                        >  5669  align:
                                                                                        >  5670  // #endif
                                                                                        >  5671  
                                                                                        >  5672  // #ifdef UNICODE
                                                                                        >  5673  // #...
                                                                                        >  5674  // #...
                                                                                        >  5675  // #...
                                                                                        >  5676  // #...
                                                                                        >  5677  // #...
                                                                                        >  5678  // #...
                                                                                        >  5679  // #...
                                                                                        >  5680  // #...
                                                                                        >  5681  // #...
                                                                                        >  5682  // #...
                                                                                        >  5683  // #...
                                                                                        >  5684  // #else
                                                                                        >  5685  alias TVN_SELCHANGINGA TVN_SELCHANGING;
                                                                                        >  5686  alias TVN_SELCHANGEDA TVN_SELCHANGED;
                                                                                        >  5687  alias TVN_GETDISPINFOA TVN_GETDISPINFO;
                                                                                        >  5688  alias TVN_SETDISPINFOA TVN_SETDISPINFO;
                                                                                        >  5689  alias TVN_ITEMEXPANDINGA TVN_ITEMEXPANDING;
                                                                                        >  5690  alias TVN_ITEMEXPANDEDA TVN_ITEMEXPANDED;
                                                                                        >  5691  alias TVN_BEGINDRAGA TVN_BEGINDRAG;
                                                                                        >  5692  alias TVN_BEGINRDRAGA TVN_BEGINRDRAG;
                                                                                        >  5693  alias TVN_DELETEITEMA TVN_DELETEITEM;
                                                                                        >  5694  alias TVN_BEGINLABELEDITA TVN_BEGINLABELEDIT;
                                                                                        >  5695  alias TVN_ENDLABELEDITA TVN_ENDLABELEDIT;
                                                                                        >  5696  // #endif
                                                                                        >  5697  
                                                                                        >  5698  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5699  // #define NMTVCUSTOMDRAW_V3_SIZE CCSIZEOF_STRUCT(NMTVCUSTOMDRAW, clrTextBk)
                                                                                        >  5700  
                                                                                        >  5701  struct tagNMTVCUSTOMDRAW {
                                                                                        >  5702    NMCUSTOMDRAW nmcd;
                                                                                        >  5703    COLORREF clrText;
                                                                                        >  5704    COLORREF clrTextBk;
                                                                                        >  5705  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5706    int iLevel;
                                                                                        >  5707  // #endif
                                                                                        >  5708  }
                                                                                        >  5709  alias tagNMTVCUSTOMDRAW NMTVCUSTOMDRAW;
                                                                                        >  5710  alias tagNMTVCUSTOMDRAW* LPNMTVCUSTOMDRAW;
                                                                                        >  5711  
                                                                                        >  5712  // #endif
                                                                                        >  5713  
                                                                                        >  5714  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5715  
                                                                                        >  5716  struct tagNMTVGETINFOTIPA {
                                                                                        >  5717    NMHDR hdr;
                                                                                        >  5718    LPSTR pszText;
                                                                                        >  5719    int cchTextMax;
                                                                                        >  5720    HTREEITEM hItem;
                                                                                        >  5721    LPARAM lParam;
                                                                                        >  5722  }
                                                                                        >  5723  alias tagNMTVGETINFOTIPA NMTVGETINFOTIPA;
                                                                                        >  5724  alias tagNMTVGETINFOTIPA* LPNMTVGETINFOTIPA;
                                                                                        >  5725  
                                                                                        >  5726  struct tagNMTVGETINFOTIPW {
                                                                                        >  5727    NMHDR hdr;
                                                                                        >  5728    LPWSTR pszText;
                                                                                        >  5729    int cchTextMax;
                                                                                        >  5730    HTREEITEM hItem;
                                                                                        >  5731    LPARAM lParam;
                                                                                        >  5732  }
                                                                                        >  5733  alias tagNMTVGETINFOTIPW NMTVGETINFOTIPW;
                                                                                        >  5734  alias tagNMTVGETINFOTIPW* LPNMTVGETINFOTIPW;
                                                                                        >  5735  
                                                                                        >  5736  // #ifdef UNICODE
                                                                                        >  5737  // #...
                                                                                        >  5738  // #...
                                                                                        >  5739  // #...
                                                                                        >  5740  // #else
                                                                                        >  5741  alias TVN_GETINFOTIPA TVN_GETINFOTIP;
                                                                                        >  5742  alias NMTVGETINFOTIPA NMTVGETINFOTIP;
                                                                                        >  5743  alias LPNMTVGETINFOTIPA LPNMTVGETINFOTIP;
                                                                                        >  5744  // #endif
                                                                                        >  5745  
                                                                                        >  5746  enum : uint { TVCDRF_NOIMAGES = 0x00010000 }
                                                                                        >  5747  
                                                                                        >  5748  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  5749  
                                                                                        >  5750  // #endif      // NOTREEVIEW
                                                                                        >  5751  
                                                                                        >  5752  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  5753  
                                                                                        >  5754  // #ifndef NOUSEREXCONTROLS
                                                                                        >  5755  
                                                                                        >  5756  const wchar[] WC_COMBOBOXEXW = "ComboBoxEx32";
                                                                                        >  5757  const char[] WC_COMBOBOXEXA = "ComboBoxEx32";
                                                                                        >  5758  
                                                                                        >  5759  // #ifdef UNICODE
                                                                                        >  5760  // #...
                                                                                        >  5761  // #else
                                                                                        >  5762  alias WC_COMBOBOXEXA WC_COMBOBOXEX;
                                                                                        >  5763  // #endif
                                                                                        >  5764  
                                                                                        >  5765  enum : uint { CBEIF_TEXT = 0x00000001 }
                                                                                        >  5766  enum : uint { CBEIF_IMAGE = 0x00000002 }
                                                                                        >  5767  enum : uint { CBEIF_SELECTEDIMAGE = 0x00000004 }
                                                                                        >  5768  enum : uint { CBEIF_OVERLAY = 0x00000008 }
                                                                                        >  5769  enum : uint { CBEIF_INDENT = 0x00000010 }
                                                                                        >  5770  enum : uint { CBEIF_LPARAM = 0x00000020 }
                                                                                        >  5771  
                                                                                        >  5772  enum : uint { CBEIF_DI_SETITEM = 0x10000000 }
                                                                                        >  5773  
                                                                                        >  5774  struct tagCOMBOBOXEXITEMA {
                                                                                        >  5775    UINT mask;
                                                                                        >  5776    INT_PTR iItem;
                                                                                        >  5777    LPSTR pszText;
                                                                                        >  5778    int cchTextMax;
                                                                                        >  5779    int iImage;
                                                                                        >  5780    int iSelectedImage;
                                                                                        >  5781    int iOverlay;
                                                                                        >  5782    int iIndent;
                                                                                        >  5783    LPARAM lParam;
                                                                                        >  5784  }
                                                                                        >  5785  alias tagCOMBOBOXEXITEMA COMBOBOXEXITEMA;
                                                                                        >  5786  alias tagCOMBOBOXEXITEMA* PCOMBOBOXEXITEMA;
                                                                                        >  5787  
                                                                                        >  5788  alias COMBOBOXEXITEMA* PCCOMBOEXITEMA;
                                                                                        >  5789  
                                                                                        >  5790  struct tagCOMBOBOXEXITEMW {
                                                                                        >  5791    UINT mask;
                                                                                        >  5792    INT_PTR iItem;
                                                                                        >  5793    LPWSTR pszText;
                                                                                        >  5794    int cchTextMax;
                                                                                        >  5795    int iImage;
                                                                                        >  5796    int iSelectedImage;
                                                                                        >  5797    int iOverlay;
                                                                                        >  5798    int iIndent;
                                                                                        >  5799    LPARAM lParam;
                                                                                        >  5800  }
                                                                                        >  5801  alias tagCOMBOBOXEXITEMW COMBOBOXEXITEMW;
                                                                                        >  5802  alias tagCOMBOBOXEXITEMW* PCOMBOBOXEXITEMW;
                                                                                        >  5803  
                                                                                        >  5804  alias COMBOBOXEXITEMW* PCCOMBOEXITEMW;
                                                                                        >  5805  
                                                                                        >  5806  // #ifdef UNICODE
                                                                                        >  5807  // #...
                                                                                        >  5808  // #...
                                                                                        >  5809  // #...
                                                                                        >  5810  // #else
                                                                                        >  5811  alias COMBOBOXEXITEMA COMBOBOXEXITEM;
                                                                                        >  5812  alias PCOMBOBOXEXITEMA PCOMBOBOXEXITEM;
                                                                                        >  5813  alias PCCOMBOBOXEXITEMA PCCOMBOBOXEXITEM;
                                                                                        >  5814  // #endif
                                                                                        >  5815  
                                                                                        >  5816  enum : uint { CBEM_INSERTITEMA = WM_USER + 1 }
                                                                                        >  5817  enum : uint { CBEM_SETIMAGELIST = WM_USER + 2 }
                                                                                        >  5818  enum : uint { CBEM_GETIMAGELIST = WM_USER + 3 }
                                                                                        >  5819  enum : uint { CBEM_GETITEMA = WM_USER + 4 }
                                                                                        >  5820  enum : uint { CBEM_SETITEMA = WM_USER + 5 }
                                                                                        >  5821  alias CB_DELETESTRING CBEM_DELETEITEM;
                                                                                        >  5822  enum : uint { CBEM_GETCOMBOCONTROL = WM_USER + 6 }
                                                                                        >  5823  enum : uint { CBEM_GETEDITCONTROL = WM_USER + 7 }
                                                                                        >  5824  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5825  enum : uint { CBEM_SETEXSTYLE = WM_USER + 8 }
                                                                                        >  5826  enum : uint { CBEM_SETEXTENDEDSTYLE = WM_USER + 14 }
                                                                                        >  5827  enum : uint { CBEM_GETEXSTYLE = WM_USER + 9 }
                                                                                        >  5828  enum : uint { CBEM_GETEXTENDEDSTYLE = WM_USER + 9 }
                                                                                        >  5829  alias CCM_SETUNICODEFORMAT CBEM_SETUNICODEFORMAT;
                                                                                        >  5830  alias CCM_GETUNICODEFORMAT CBEM_GETUNICODEFORMAT;
                                                                                        >  5831  // #else
                                                                                        >  5832  // #...
                                                                                        >  5833  // #...
                                                                                        >  5834  // #endif
                                                                                        >  5835  enum : uint { CBEM_HASEDITCHANGED = WM_USER + 10 }
                                                                                        >  5836  enum : uint { CBEM_INSERTITEMW = WM_USER + 11 }
                                                                                        >  5837  enum : uint { CBEM_SETITEMW = WM_USER + 12 }
                                                                                        >  5838  enum : uint { CBEM_GETITEMW = WM_USER + 13 }
                                                                                        >  5839  
                                                                                        >  5840  // #ifdef UNICODE
                                                                                        >  5841  // #...
                                                                                        >  5842  // #...
                                                                                        >  5843  // #...
                                                                                        >  5844  // #else
                                                                                        >  5845  alias CBEM_INSERTITEMA CBEM_INSERTITEM;
                                                                                        >  5846  alias CBEM_SETITEMA CBEM_SETITEM;
                                                                                        >  5847  alias CBEM_GETITEMA CBEM_GETITEM;
                                                                                        >  5848  // #endif
                                                                                        >  5849  
                                                                                        >  5850  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  5851  alias CCM_SETWINDOWTHEME CBEM_SETWINDOWTHEME;
                                                                                        >  5852  // #endif
                                                                                        >  5853  
                                                                                        >  5854  enum : uint { CBES_EX_NOEDITIMAGE = 0x00000001 }
                                                                                        >  5855  enum : uint { CBES_EX_NOEDITIMAGEINDENT = 0x00000002 }
                                                                                        >  5856  enum : uint { CBES_EX_PATHWORDBREAKPROC = 0x00000004 }
                                                                                        >  5857  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5858  enum : uint { CBES_EX_NOSIZELIMIT = 0x00000008 }
                                                                                        >  5859  enum : uint { CBES_EX_CASESENSITIVE = 0x00000010 }
                                                                                        >  5860  
                                                                                        >  5861  struct _9 {
                                                                                        >  5862    NMHDR hdr;
                                                                                        >  5863    COMBOBOXEXITEMA ceItem;
                                                                                        >  5864  }
                                                                                        >  5865  alias _9 NMCOMBOBOXEXA;
                                                                                        >  5866  alias _9* PNMCOMBOBOXEXA;
                                                                                        >  5867  
                                                                                        >  5868  struct _10 {
                                                                                        >  5869    NMHDR hdr;
                                                                                        >  5870    COMBOBOXEXITEMW ceItem;
                                                                                        >  5871  }
                                                                                        >  5872  alias _10 NMCOMBOBOXEXW;
                                                                                        >  5873  alias _10* PNMCOMBOBOXEXW;
                                                                                        >  5874  
                                                                                        >  5875  // #ifdef UNICODE
                                                                                        >  5876  // #...
                                                                                        >  5877  // #...
                                                                                        >  5878  // #...
                                                                                        >  5879  // #else
                                                                                        >  5880  alias NMCOMBOBOXEXA NMCOMBOBOXEX;
                                                                                        >  5881  alias PNMCOMBOBOXEXA PNMCOMBOBOXEX;
                                                                                        >  5882  alias CBEN_GETDISPINFOA CBEN_GETDISPINFO;
                                                                                        >  5883  // #endif
                                                                                        >  5884  
                                                                                        >  5885  // #else
                                                                                        >  5886  // ...
                                                                                        >  5887  
                                                                                        >  5888  // #...
                                                                                        >  5889  
                                                                                        >  5890  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  5891  
                                                                                        >  5892  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5893  // #define CBEN_GETDISPINFOA (CBEN_FIRST - 0)
                                                                                        >  5894  // #endif
                                                                                        >  5895  enum : uint { CBEN_INSERTITEM = CBEN_FIRST - 1 }
                                                                                        >  5896  enum : uint { CBEN_DELETEITEM = CBEN_FIRST - 2 }
                                                                                        >  5897  enum : uint { CBEN_BEGINEDIT = CBEN_FIRST - 4 }
                                                                                        >  5898  enum : uint { CBEN_ENDEDITA = CBEN_FIRST - 5 }
                                                                                        >  5899  enum : uint { CBEN_ENDEDITW = CBEN_FIRST - 6 }
                                                                                        >  5900  
                                                                                        >  5901  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5902  // #define CBEN_GETDISPINFOW (CBEN_FIRST - 7)
                                                                                        >  5903  // #endif
                                                                                        >  5904  
                                                                                        >  5905  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5906  enum : uint { CBEN_DRAGBEGINA = CBEN_FIRST - 8 }
                                                                                        >  5907  enum : uint { CBEN_DRAGBEGINW = CBEN_FIRST - 9 }
                                                                                        >  5908  
                                                                                        >  5909  // #ifdef UNICODE
                                                                                        >  5910  // #...
                                                                                        >  5911  // #else
                                                                                        >  5912  alias CBEN_DRAGBEGINA CBEN_DRAGBEGIN;
                                                                                        >  5913  // #endif
                                                                                        >  5914  
                                                                                        >  5915  // #endif  //(_WIN32_IE >= 0x0400)
                                                                                        >  5916  
                                                                                        >  5917  // #ifdef UNICODE
                                                                                        >  5918  // #...
                                                                                        >  5919  // #else
                                                                                        >  5920  alias CBEN_ENDEDITA CBEN_ENDEDIT;
                                                                                        >  5921  // #endif
                                                                                        >  5922  
                                                                                        >  5923  enum : uint { CBENF_KILLFOCUS = 1 }
                                                                                        >  5924  enum : uint { CBENF_RETURN = 2 }
                                                                                        >  5925  enum : uint { CBENF_ESCAPE = 3 }
                                                                                        >  5926  enum : uint { CBENF_DROPDOWN = 4 }
                                                                                        >  5927  
                                                                                        >  5928  enum : uint { CBEMAXSTRLEN = 260 }
                                                                                        >  5929  
                                                                                        >  5930  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  5931  
                                                                                        >  5932  struct _11 {
                                                                                        >  5933    NMHDR hdr;
                                                                                        >  5934    int iItemid;
                                                                                        >  5935    WCHAR szText[CBEMAXSTRLEN];
                                                                                        >  5936  }
                                                                                        >  5937  alias _11 NMCBEDRAGBEGINW;
                                                                                        >  5938  alias _11* LPNMCBEDRAGBEGINW;
                                                                                        >  5939  alias _11* PNMCBEDRAGBEGINW;
                                                                                        >  5940  
                                                                                        >  5941  struct _12 {
                                                                                        >  5942    NMHDR hdr;
                                                                                        >  5943    int iItemid;
                                                                                        >  5944    char szText[CBEMAXSTRLEN];
                                                                                        >  5945  }
                                                                                        >  5946  alias _12 NMCBEDRAGBEGINA;
                                                                                        >  5947  alias _12* LPNMCBEDRAGBEGINA;
                                                                                        >  5948  alias _12* PNMCBEDRAGBEGINA;
                                                                                        >  5949  
                                                                                        >  5950  // #ifdef UNICODE
                                                                                        >  5951  // #...
                                                                                        >  5952  // #...
                                                                                        >  5953  // #...
                                                                                        >  5954  // #else
                                                                                        >  5955  alias NMCBEDRAGBEGINA NMCBEDRAGBEGIN;
                                                                                        >  5956  alias LPNMCBEDRAGBEGINA LPNMCBEDRAGBEGIN;
                                                                                        >  5957  alias PNMCBEDRAGBEGINA PNMCBEDRAGBEGIN;
                                                                                        >  5958  // #endif
                                                                                        >  5959  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  5960  
                                                                                        >  5961  struct _13 {
                                                                                        >  5962    NMHDR hdr;
                                                                                        >  5963    BOOL fChanged;
                                                                                        >  5964    int iNewSelection;
                                                                                        >  5965    WCHAR szText[CBEMAXSTRLEN];
                                                                                        >  5966    int iWhy;
                                                                                        >  5967  }
                                                                                        >  5968  alias _13 NMCBEENDEDITW;
                                                                                        >  5969  alias _13* LPNMCBEENDEDITW;
                                                                                        >  5970  alias _13* PNMCBEENDEDITW;
                                                                                        >  5971  
                                                                                        >  5972  struct _14 {
                                                                                        >  5973    NMHDR hdr;
                                                                                        >  5974    BOOL fChanged;
                                                                                        >  5975    int iNewSelection;
                                                                                        >  5976    char szText[CBEMAXSTRLEN];
                                                                                        >  5977    int iWhy;
                                                                                        >  5978  }
                                                                                        >  5979  alias _14 NMCBEENDEDITA;
                                                                                        >  5980  alias _14* LPNMCBEENDEDITA;
                                                                                        >  5981  alias _14* PNMCBEENDEDITA;
                                                                                        >  5982  
                                                                                        >  5983  // #ifdef UNICODE
                                                                                        >  5984  // #...
                                                                                        >  5985  // #...
                                                                                        >  5986  // #...
                                                                                        >  5987  // #else
                                                                                        >  5988  alias NMCBEENDEDITA NMCBEENDEDIT;
                                                                                        >  5989  alias LPNMCBEENDEDITA LPNMCBEENDEDIT;
                                                                                        >  5990  alias PNMCBEENDEDITA PNMCBEENDEDIT;
                                                                                        >  5991  // #endif
                                                                                        >  5992  
                                                                                        >  5993  // #endif
                                                                                        >  5994  
                                                                                        >  5995  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  5996  
                                                                                        >  5997  // #ifndef NOTABCONTROL
                                                                                        >  5998  
                                                                                        >  5999  // #ifdef _WIN32
                                                                                        >  6000  
                                                                                        >  6001  const char[] WC_TABCONTROLA = "SysTabControl32";
                                                                                        >  6002  const wchar[] WC_TABCONTROLW = "SysTabControl32";
                                                                                        >  6003  
                                                                                        >  6004  // #ifdef UNICODE
                                                                                        >  6005  // #...
                                                                                        >  6006  // #else
                                                                                        >  6007  alias WC_TABCONTROLA WC_TABCONTROL;
                                                                                        >  6008  // #endif
                                                                                        >  6009  
                                                                                        >  6010  // #else
                                                                                        >  6011  // #...
                                                                                        >  6012  // #endif
                                                                                        >  6013  
                                                                                        >  6014  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6015  enum : uint { TCS_SCROLLOPPOSITE = 0x0001 }
                                                                                        >  6016  enum : uint { TCS_BOTTOM = 0x0002 }
                                                                                        >  6017  enum : uint { TCS_RIGHT = 0x0002 }
                                                                                        >  6018  enum : uint { TCS_MULTISELECT = 0x0004 }
                                                                                        >  6019  // #endif
                                                                                        >  6020  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6021  enum : uint { TCS_FLATBUTTONS = 0x0008 }
                                                                                        >  6022  // #endif
                                                                                        >  6023  enum : uint { TCS_FORCEICONLEFT = 0x0010 }
                                                                                        >  6024  enum : uint { TCS_FORCELABELLEFT = 0x0020 }
                                                                                        >  6025  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6026  enum : uint { TCS_HOTTRACK = 0x0040 }
                                                                                        >  6027  enum : uint { TCS_VERTICAL = 0x0080 }
                                                                                        >  6028  // #endif
                                                                                        >  6029  enum : uint { TCS_TABS = 0x0000 }
                                                                                        >  6030  enum : uint { TCS_BUTTONS = 0x0100 }
                                                                                        >  6031  enum : uint { TCS_SINGLELINE = 0x0000 }
                                                                                        >  6032  enum : uint { TCS_MULTILINE = 0x0200 }
                                                                                        >  6033  enum : uint { TCS_RIGHTJUSTIFY = 0x0000 }
                                                                                        >  6034  enum : uint { TCS_FIXEDWIDTH = 0x0400 }
                                                                                        >  6035  enum : uint { TCS_RAGGEDRIGHT = 0x0800 }
                                                                                        >  6036  enum : uint { TCS_FOCUSONBUTTONDOWN = 0x1000 }
                                                                                        >  6037  enum : uint { TCS_OWNERDRAWFIXED = 0x2000 }
                                                                                        >  6038  enum : uint { TCS_TOOLTIPS = 0x4000 }
                                                                                        >  6039  enum : uint { TCS_FOCUSNEVER = 0x8000 }
                                                                                        >  6040  
                                                                                        >  6041  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6042  
                                                                                        >  6043  enum : uint { TCS_EX_FLATSEPARATORS = 0x00000001 }
                                                                                        >  6044  enum : uint { TCS_EX_REGISTERDROP = 0x00000002 }
                                                                                        >  6045  // #endif
                                                                                        >  6046  
                                                                                        >  6047  enum : uint { TCM_GETIMAGELIST = TCM_FIRST + 2 }
                                                                                        >  6048  // #define TabCtrl_GetImageList(hwnd) (HIMAGELIST)SNDMSG((hwnd), TCM_GETIMAGELIS
                                                                                        >  6049  
                                                                                        >  6050  enum : uint { TCM_SETIMAGELIST = TCM_FIRST + 3 }
                                                                                        >  6051  // #define TabCtrl_SetImageList(hwnd, himl) (HIMAGELIST)SNDMSG((hwnd), TCM_SETIM
                                                                                        >  6052  
                                                                                        >  6053  enum : uint { TCM_GETITEMCOUNT = TCM_FIRST + 4 }
                                                                                        >  6054  // #define TabCtrl_GetItemCount(hwnd) (int)SNDMSG((hwnd), TCM_GETITEMCOUNT, 0, 0
                                                                                        >  6055  
                                                                                        >  6056  enum : uint { TCIF_TEXT = 0x0001 }
                                                                                        >  6057  enum : uint { TCIF_IMAGE = 0x0002 }
                                                                                        >  6058  enum : uint { TCIF_RTLREADING = 0x0004 }
                                                                                        >  6059  enum : uint { TCIF_PARAM = 0x0008 }
                                                                                        >  6060  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6061  enum : uint { TCIF_STATE = 0x0010 }
                                                                                        >  6062  
                                                                                        >  6063  enum : uint { TCIS_BUTTONPRESSED = 0x0001 }
                                                                                        >  6064  // #endif
                                                                                        >  6065  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6066  enum : uint { TCIS_HIGHLIGHTED = 0x0002 }
                                                                                        >  6067  // #endif
                                                                                        >  6068  
                                                                                        >  6069  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6070  alias TCITEMHEADERA TC_ITEMHEADERA;
                                                                                        >  6071  alias TCITEMHEADERW TC_ITEMHEADERW;
                                                                                        >  6072  // #else
                                                                                        >  6073  // #...
                                                                                        >  6074  // #...
                                                                                        >  6075  // #...
                                                                                        >  6076  // #...
                                                                                        >  6077  // #endif
                                                                                        >  6078  alias TCITEMHEADER TC_ITEMHEADER;
                                                                                        >  6079  
                                                                                        >  6080  struct tagTCITEMHEADERA {
                                                                                        >  6081    UINT mask;
                                                                                        >  6082    UINT lpReserved1;
                                                                                        >  6083    UINT lpReserved2;
                                                                                        >  6084    LPSTR pszText;
                                                                                        >  6085    int cchTextMax;
                                                                                        >  6086    int iImage;
                                                                                        >  6087  }
                                                                                        >  6088  alias tagTCITEMHEADERA TCITEMHEADERA;
                                                                                        >  6089  alias tagTCITEMHEADERA* LPTCITEMHEADERA;
                                                                                        >  6090  
                                                                                        >  6091  struct tagTCITEMHEADERW {
                                                                                        >  6092    UINT mask;
                                                                                        >  6093    UINT lpReserved1;
                                                                                        >  6094    UINT lpReserved2;
                                                                                        >  6095    LPWSTR pszText;
                                                                                        >  6096    int cchTextMax;
                                                                                        >  6097    int iImage;
                                                                                        >  6098  }
                                                                                        >  6099  alias tagTCITEMHEADERW TCITEMHEADERW;
                                                                                        >  6100  alias tagTCITEMHEADERW* LPTCITEMHEADERW;
                                                                                        >  6101  
                                                                                        >  6102  // #ifdef UNICODE
                                                                                        >  6103  // #...
                                                                                        >  6104  // #...
                                                                                        >  6105  // #else
                                                                                        >  6106  alias TCITEMHEADERA TCITEMHEADER;
                                                                                        >  6107  alias LPTCITEMHEADERA LPTCITEMHEADER;
                                                                                        >  6108  // #endif
                                                                                        >  6109  
                                                                                        >  6110  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6111  alias TCITEMA TC_ITEMA;
                                                                                        >  6112  alias TCITEMW TC_ITEMW;
                                                                                        >  6113  // #else
                                                                                        >  6114  // #...
                                                                                        >  6115  // #...
                                                                                        >  6116  // #...
                                                                                        >  6117  // #...
                                                                                        >  6118  // #endif
                                                                                        >  6119  alias TCITEM TC_ITEM;
                                                                                        >  6120  
                                                                                        >  6121  struct tagTCITEMA {
                                                                                        >  6122    UINT mask;
                                                                                        >  6123  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6124    DWORD dwState;
                                                                                        >  6125    DWORD dwStateMask;
                                                                                        >  6126  // #else
                                                                                        >  6127  // ...
                                                                                        >  6128  // #endif
                                                                                        >  6129    LPSTR pszText;
                                                                                        >  6130    int cchTextMax;
                                                                                        >  6131    int iImage;
                                                                                        >  6132    LPARAM lParam;
                                                                                        >  6133  }
                                                                                        >  6134  alias tagTCITEMA TCITEMA;
                                                                                        >  6135  alias tagTCITEMA* LPTCITEMA;
                                                                                        >  6136  
                                                                                        >  6137  struct tagTCITEMW {
                                                                                        >  6138    UINT mask;
                                                                                        >  6139  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6140    DWORD dwState;
                                                                                        >  6141    DWORD dwStateMask;
                                                                                        >  6142  // #else
                                                                                        >  6143  // ...
                                                                                        >  6144  // #endif
                                                                                        >  6145    LPWSTR pszText;
                                                                                        >  6146    int cchTextMax;
                                                                                        >  6147    int iImage;
                                                                                        >  6148    LPARAM lParam;
                                                                                        >  6149  }
                                                                                        >  6150  alias tagTCITEMW TCITEMW;
                                                                                        >  6151  alias tagTCITEMW* LPTCITEMW;
                                                                                        >  6152  
                                                                                        >  6153  // #ifdef UNICODE
                                                                                        >  6154  // #...
                                                                                        >  6155  // #...
                                                                                        >  6156  // #else
                                                                                        >  6157  alias TCITEMA TCITEM;
                                                                                        >  6158  alias LPTCITEMA LPTCITEM;
                                                                                        >  6159  // #endif
                                                                                        >  6160  
                                                                                        >  6161  enum : uint { TCM_GETITEMA = TCM_FIRST + 5 }
                                                                                        >  6162  enum : uint { TCM_GETITEMW = TCM_FIRST + 60 }
                                                                                        >  6163  
                                                                                        >  6164  // #ifdef UNICODE
                                                                                        >  6165  // #...
                                                                                        >  6166  // #else
                                                                                        >  6167  alias TCM_GETITEMA TCM_GETITEM;
                                                                                        >  6168  // #endif
                                                                                        >  6169  
                                                                                        >  6170  // #define TabCtrl_GetItem(hwnd, iItem, pitem) (BOOL)SNDMSG((hwnd), TCM_GETITEM,
                                                                                        >  6171  
                                                                                        >  6172  enum : uint { TCM_SETITEMA = TCM_FIRST + 6 }
                                                                                        >  6173  enum : uint { TCM_SETITEMW = TCM_FIRST + 61 }
                                                                                        >  6174  
                                                                                        >  6175  // #ifdef UNICODE
                                                                                        >  6176  // #...
                                                                                        >  6177  // #else
                                                                                        >  6178  alias TCM_SETITEMA TCM_SETITEM;
                                                                                        >  6179  // #endif
                                                                                        >  6180  
                                                                                        >  6181  // #define TabCtrl_SetItem(hwnd, iItem, pitem) (BOOL)SNDMSG((hwnd), TCM_SETITEM,
                                                                                        >  6182  
                                                                                        >  6183  enum : uint { TCM_INSERTITEMA = TCM_FIRST + 7 }
                                                                                        >  6184  enum : uint { TCM_INSERTITEMW = TCM_FIRST + 62 }
                                                                                        >  6185  
                                                                                        >  6186  // #ifdef UNICODE
                                                                                        >  6187  // #...
                                                                                        >  6188  // #else
                                                                                        >  6189  alias TCM_INSERTITEMA TCM_INSERTITEM;
                                                                                        >  6190  // #endif
                                                                                        >  6191  
                                                                                        >  6192  // #define TabCtrl_InsertItem(hwnd, iItem, pitem) (int)SNDMSG((hwnd), TCM_INSERT
                                                                                        >  6193  
                                                                                        >  6194  enum : uint { TCM_DELETEITEM = TCM_FIRST + 8 }
                                                                                        >  6195  // #define TabCtrl_DeleteItem(hwnd, i) (BOOL)SNDMSG((hwnd), TCM_DELETEITEM, (WPA
                                                                                        >  6196  
                                                                                        >  6197  enum : uint { TCM_DELETEALLITEMS = TCM_FIRST + 9 }
                                                                                        >  6198  // #define TabCtrl_DeleteAllItems(hwnd) (BOOL)SNDMSG((hwnd), TCM_DELETEALLITEMS,
                                                                                        >  6199  
                                                                                        >  6200  enum : uint { TCM_GETITEMRECT = TCM_FIRST + 10 }
                                                                                        >  6201  // #define TabCtrl_GetItemRect(hwnd, i, prc) (BOOL)SNDMSG((hwnd), TCM_GETITEMREC
                                                                                        >  6202  
                                                                                        >  6203  enum : uint { TCM_GETCURSEL = TCM_FIRST + 11 }
                                                                                        >  6204  // #define TabCtrl_GetCurSel(hwnd) (int)SNDMSG((hwnd), TCM_GETCURSEL, 0, 0)
                                                                                        >  6205  
                                                                                        >  6206  enum : uint { TCM_SETCURSEL = TCM_FIRST + 12 }
                                                                                        >  6207  // #define TabCtrl_SetCurSel(hwnd, i) (int)SNDMSG((hwnd), TCM_SETCURSEL, (WPARAM
                                                                                        >  6208  
                                                                                        >  6209  enum : uint { TCHT_NOWHERE = 0x0001 }
                                                                                        >  6210  enum : uint { TCHT_ONITEMICON = 0x0002 }
                                                                                        >  6211  enum : uint { TCHT_ONITEMLABEL = 0x0004 }
                                                                                        >  6212  enum : uint { TCHT_ONITEM = TCHT_ONITEMICON | TCHT_ONITEMLABEL }
                                                                                        >  6213  
                                                                                        >  6214  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6215  alias LPTCHITTESTINFO LPTC_HITTESTINFO;
                                                                                        >  6216  alias TCHITTESTINFO TC_HITTESTINFO;
                                                                                        >  6217  // #else
                                                                                        >  6218  // #...
                                                                                        >  6219  // #...
                                                                                        >  6220  // #...
                                                                                        >  6221  // #endif
                                                                                        >  6222  
                                                                                        >  6223  struct tagTCHITTESTINFO {
                                                                                        >  6224    POINT pt;
                                                                                        >  6225    UINT flags;
                                                                                        >  6226  }
                                                                                        >  6227  alias tagTCHITTESTINFO TCHITTESTINFO;
                                                                                        >  6228  alias tagTCHITTESTINFO* LPTCHITTESTINFO;
                                                                                        >  6229  
                                                                                        >  6230  enum : uint { TCM_HITTEST = TCM_FIRST + 13 }
                                                                                        >  6231  // #define TabCtrl_HitTest(hwndTC, pinfo) (int)SNDMSG((hwndTC), TCM_HITTEST, 0, 
                                                                                        >  6232  
                                                                                        >  6233  enum : uint { TCM_SETITEMEXTRA = TCM_FIRST + 14 }
                                                                                        >  6234  // #define TabCtrl_SetItemExtra(hwndTC, cb) (BOOL)SNDMSG((hwndTC), TCM_SETITEMEX
                                                                                        >  6235  
                                                                                        >  6236  enum : uint { TCM_ADJUSTRECT = TCM_FIRST + 40 }
                                                                                        >  6237  // #define TabCtrl_AdjustRect(hwnd, bLarger, prc) (int)SNDMSG(hwnd, TCM_ADJUSTRE
                                                                                        >  6238  
                                                                                        >  6239  enum : uint { TCM_SETITEMSIZE = TCM_FIRST + 41 }
                                                                                        >  6240  // #define TabCtrl_SetItemSize(hwnd, x, y) (DWORD)SNDMSG((hwnd), TCM_SETITEMSIZE
                                                                                        >  6241  
                                                                                        >  6242  enum : uint { TCM_REMOVEIMAGE = TCM_FIRST + 42 }
                                                                                        >  6243  // #define TabCtrl_RemoveImage(hwnd, i) (void)SNDMSG((hwnd), TCM_REMOVEIMAGE, i,
                                                                                        >  6244  
                                                                                        >  6245  enum : uint { TCM_SETPADDING = TCM_FIRST + 43 }
                                                                                        >  6246  // #define TabCtrl_SetPadding(hwnd, cx, cy) (void)SNDMSG((hwnd), TCM_SETPADDING,
                                                                                        >  6247  
                                                                                        >  6248  enum : uint { TCM_GETROWCOUNT = TCM_FIRST + 44 }
                                                                                        >  6249  // #define TabCtrl_GetRowCount(hwnd) (int)SNDMSG((hwnd), TCM_GETROWCOUNT, 0, 0L)
                                                                                        >  6250  
                                                                                        >  6251  enum : uint { TCM_GETTOOLTIPS = TCM_FIRST + 45 }
                                                                                        >  6252  // #define TabCtrl_GetToolTips(hwnd) (HWND)SNDMSG((hwnd), TCM_GETTOOLTIPS, 0, 0L
                                                                                        >  6253  
                                                                                        >  6254  enum : uint { TCM_SETTOOLTIPS = TCM_FIRST + 46 }
                                                                                        >  6255  // #define TabCtrl_SetToolTips(hwnd, hwndTT) (void)SNDMSG((hwnd), TCM_SETTOOLTIP
                                                                                        >  6256  
                                                                                        >  6257  enum : uint { TCM_GETCURFOCUS = TCM_FIRST + 47 }
                                                                                        >  6258  // #define TabCtrl_GetCurFocus(hwnd) (int)SNDMSG((hwnd), TCM_GETCURFOCUS, 0, 0)
                                                                                        >  6259  
                                                                                        >  6260  enum : uint { TCM_SETCURFOCUS = TCM_FIRST + 48 }
                                                                                        >  6261  // #define TabCtrl_SetCurFocus(hwnd, i) SNDMSG((hwnd),TCM_SETCURFOCUS, i, 0)
                                                                                        >  6262  
                                                                                        >  6263  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6264  enum : uint { TCM_SETMINTABWIDTH = TCM_FIRST + 49 }
                                                                                        >  6265  // #define TabCtrl_SetMinTabWidth(hwnd, x) (int)SNDMSG((hwnd), TCM_SETMINTABWIDT
                                                                                        >  6266  
                                                                                        >  6267  enum : uint { TCM_DESELECTALL = TCM_FIRST + 50 }
                                                                                        >  6268  // #define TabCtrl_DeselectAll(hwnd, fExcludeFocus) (void)SNDMSG((hwnd), TCM_DES
                                                                                        >  6269  // #endif
                                                                                        >  6270  
                                                                                        >  6271  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6272  
                                                                                        >  6273  enum : uint { TCM_HIGHLIGHTITEM = TCM_FIRST + 51 }
                                                                                        >  6274  // #define TabCtrl_HighlightItem(hwnd, i, fHighlight) (BOOL)SNDMSG((hwnd), TCM_H
                                                                                        >  6275  
                                                                                        >  6276  enum : uint { TCM_SETEXTENDEDSTYLE = TCM_FIRST + 52 }
                                                                                        >  6277  // #define TabCtrl_SetExtendedStyle(hwnd, dw) (DWORD)SNDMSG((hwnd), TCM_SETEXTEN
                                                                                        >  6278  
                                                                                        >  6279  enum : uint { TCM_GETEXTENDEDSTYLE = TCM_FIRST + 53 }
                                                                                        >  6280  // #define TabCtrl_GetExtendedStyle(hwnd) (DWORD)SNDMSG((hwnd), TCM_GETEXTENDEDS
                                                                                        >  6281  
                                                                                        >  6282  alias CCM_SETUNICODEFORMAT TCM_SETUNICODEFORMAT;
                                                                                        >  6283  // #define TabCtrl_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), TCM_SET
                                                                                        >  6284  
                                                                                        >  6285  alias CCM_GETUNICODEFORMAT TCM_GETUNICODEFORMAT;
                                                                                        >  6286  // #define TabCtrl_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), TCM_GETUNICODEFOR
                                                                                        >  6287  
                                                                                        >  6288  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  6289  
                                                                                        >  6290  enum : uint { TCN_KEYDOWN = TCN_FIRST - 0 }
                                                                                        >  6291  
                                                                                        >  6292  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6293  alias NMTCKEYDOWN TC_KEYDOWN;
                                                                                        >  6294  // #else
                                                                                        >  6295  // #...
                                                                                        >  6296  // #...
                                                                                        >  6297  // #endif
                                                                                        >  6298  
                                                                                        >  6299  // #ifdef _WIN32
                                                                                        >  6300  align(1):
                                                                                        >  6301  // #endif
                                                                                        >  6302  
                                                                                        >  6303  struct tagTCKEYDOWN {
                                                                                        >  6304    NMHDR hdr;
                                                                                        >  6305    WORD wVKey;
                                                                                        >  6306    UINT flags;
                                                                                        >  6307  }
                                                                                        >  6308  alias tagTCKEYDOWN NMTCKEYDOWN;
                                                                                        >  6309  
                                                                                        >  6310  // #ifdef _WIN32
                                                                                        >  6311  align:
                                                                                        >  6312  // #endif
                                                                                        >  6313  
                                                                                        >  6314  enum : uint { TCN_SELCHANGE = TCN_FIRST - 1 }
                                                                                        >  6315  enum : uint { TCN_SELCHANGING = TCN_FIRST - 2 }
                                                                                        >  6316  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6317  enum : uint { TCN_GETOBJECT = TCN_FIRST - 3 }
                                                                                        >  6318  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  6319  // #if (_WIN32_IE >= 0x0500)
                                                                                        >  6320  enum : uint { TCN_FOCUSCHANGE = TCN_FIRST - 4 }
                                                                                        >  6321  // #endif      // _WIN32_IE >= 0x0500
                                                                                        >  6322  // #endif      // NOTABCONTROL
                                                                                        >  6323  
                                                                                        >  6324  // #ifndef NOANIMATE
                                                                                        >  6325  
                                                                                        >  6326  // #ifdef _WIN32
                                                                                        >  6327  
                                                                                        >  6328  const wchar[] ANIMATE_CLASSW = "SysAnimate32";
                                                                                        >  6329  const char[] ANIMATE_CLASSA = "SysAnimate32";
                                                                                        >  6330  
                                                                                        >  6331  // #ifdef UNICODE
                                                                                        >  6332  // #...
                                                                                        >  6333  // #else
                                                                                        >  6334  alias ANIMATE_CLASSA ANIMATE_CLASS;
                                                                                        >  6335  // #endif
                                                                                        >  6336  
                                                                                        >  6337  enum : uint { ACS_CENTER = 0x0001 }
                                                                                        >  6338  enum : uint { ACS_TRANSPARENT = 0x0002 }
                                                                                        >  6339  enum : uint { ACS_AUTOPLAY = 0x0004 }
                                                                                        >  6340  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6341  enum : uint { ACS_TIMER = 0x0008 }
                                                                                        >  6342  // #endif
                                                                                        >  6343  
                                                                                        >  6344  enum : uint { ACM_OPENA = WM_USER+100 }
                                                                                        >  6345  enum : uint { ACM_OPENW = WM_USER+103 }
                                                                                        >  6346  
                                                                                        >  6347  // #ifdef UNICODE
                                                                                        >  6348  // #...
                                                                                        >  6349  // #else
                                                                                        >  6350  alias ACM_OPENA ACM_OPEN;
                                                                                        >  6351  // #endif
                                                                                        >  6352  
                                                                                        >  6353  enum : uint { ACM_PLAY = WM_USER+101 }
                                                                                        >  6354  enum : uint { ACM_STOP = WM_USER+102 }
                                                                                        >  6355  
                                                                                        >  6356  enum : uint { ACN_START = 1 }
                                                                                        >  6357  enum : uint { ACN_STOP = 2 }
                                                                                        >  6358  
                                                                                        >  6359  // #define Animate_Create(hwndP, id, dwStyle, hInstance) CreateWindow(ANIMATE_CL
                                                                                        >  6360  
                                                                                        >  6361  // #define Animate_Open(hwnd, szName) (BOOL)SNDMSG(hwnd, ACM_OPEN, 0, (LPARAM)(L
                                                                                        >  6362  // #define Animate_OpenEx(hwnd, hInst, szName) (BOOL)SNDMSG(hwnd, ACM_OPEN, (WPA
                                                                                        >  6363  // #define Animate_Play(hwnd, from, to, rep) (BOOL)SNDMSG(hwnd, ACM_PLAY, (WPARA
                                                                                        >  6364  // #define Animate_Stop(hwnd) (BOOL)SNDMSG(hwnd, ACM_STOP, 0, 0)
                                                                                        >  6365  // #define Animate_Close(hwnd) Animate_Open(hwnd, NULL)
                                                                                        >  6366  // #define Animate_Seek(hwnd, frame) Animate_Play(hwnd, frame, frame, 1)
                                                                                        >  6367  // #endif
                                                                                        >  6368  
                                                                                        >  6369  // #endif      // NOANIMATE
                                                                                        >  6370  
                                                                                        >  6371  // #if (_WIN32_IE >= 0x0300)
                                                                                        >  6372  
                                                                                        >  6373  // #ifndef NOMONTHCAL
                                                                                        >  6374  // #ifdef _WIN32
                                                                                        >  6375  
                                                                                        >  6376  const wchar[] MONTHCAL_CLASSW = "SysMonthCal32";
                                                                                        >  6377  const char[] MONTHCAL_CLASSA = "SysMonthCal32";
                                                                                        >  6378  
                                                                                        >  6379  // #ifdef UNICODE
                                                                                        >  6380  // #...
                                                                                        >  6381  // #else
                                                                                        >  6382  alias MONTHCAL_CLASSA MONTHCAL_CLASS;
                                                                                        >  6383  // #endif
                                                                                        >  6384  
                                                                                        >  6385  alias DWORD MONTHDAYSTATE;
                                                                                        >  6386  alias DWORD* LPMONTHDAYSTATE;
                                                                                        >  6387  
                                                                                        >  6388  enum : uint { MCM_FIRST = 0x1000 }
                                                                                        >  6389  
                                                                                        >  6390  enum : uint { MCM_GETCURSEL = MCM_FIRST + 1 }
                                                                                        >  6391  // #define MonthCal_GetCurSel(hmc, pst) (BOOL)SNDMSG(hmc, MCM_GETCURSEL, 0, (LPA
                                                                                        >  6392  
                                                                                        >  6393  enum : uint { MCM_SETCURSEL = MCM_FIRST + 2 }
                                                                                        >  6394  // #define MonthCal_SetCurSel(hmc, pst) (BOOL)SNDMSG(hmc, MCM_SETCURSEL, 0, (LPA
                                                                                        >  6395  
                                                                                        >  6396  enum : uint { MCM_GETMAXSELCOUNT = MCM_FIRST + 3 }
                                                                                        >  6397  // #define MonthCal_GetMaxSelCount(hmc) (DWORD)SNDMSG(hmc, MCM_GETMAXSELCOUNT, 0
                                                                                        >  6398  
                                                                                        >  6399  enum : uint { MCM_SETMAXSELCOUNT = MCM_FIRST + 4 }
                                                                                        >  6400  // #define MonthCal_SetMaxSelCount(hmc, n) (BOOL)SNDMSG(hmc, MCM_SETMAXSELCOUNT,
                                                                                        >  6401  
                                                                                        >  6402  enum : uint { MCM_GETSELRANGE = MCM_FIRST + 5 }
                                                                                        >  6403  // #define MonthCal_GetSelRange(hmc, rgst) SNDMSG(hmc, MCM_GETSELRANGE, 0, (LPAR
                                                                                        >  6404  
                                                                                        >  6405  enum : uint { MCM_SETSELRANGE = MCM_FIRST + 6 }
                                                                                        >  6406  // #define MonthCal_SetSelRange(hmc, rgst) SNDMSG(hmc, MCM_SETSELRANGE, 0, (LPAR
                                                                                        >  6407  
                                                                                        >  6408  enum : uint { MCM_GETMONTHRANGE = MCM_FIRST + 7 }
                                                                                        >  6409  // #define MonthCal_GetMonthRange(hmc, gmr, rgst) (DWORD)SNDMSG(hmc, MCM_GETMONT
                                                                                        >  6410  
                                                                                        >  6411  enum : uint { MCM_SETDAYSTATE = MCM_FIRST + 8 }
                                                                                        >  6412  // #define MonthCal_SetDayState(hmc, cbds, rgds) SNDMSG(hmc, MCM_SETDAYSTATE, (W
                                                                                        >  6413  
                                                                                        >  6414  enum : uint { MCM_GETMINREQRECT = MCM_FIRST + 9 }
                                                                                        >  6415  // #define MonthCal_GetMinReqRect(hmc, prc) SNDMSG(hmc, MCM_GETMINREQRECT, 0, (L
                                                                                        >  6416  
                                                                                        >  6417  enum : uint { MCM_SETCOLOR = MCM_FIRST + 10 }
                                                                                        >  6418  // #define MonthCal_SetColor(hmc, iColor, clr) SNDMSG(hmc, MCM_SETCOLOR, iColor,
                                                                                        >  6419  
                                                                                        >  6420  enum : uint { MCM_GETCOLOR = MCM_FIRST + 11 }
                                                                                        >  6421  // #define MonthCal_GetColor(hmc, iColor) SNDMSG(hmc, MCM_GETCOLOR, iColor, 0)
                                                                                        >  6422  
                                                                                        >  6423  enum : uint { MCSC_BACKGROUND = 0 }
                                                                                        >  6424  enum : uint { MCSC_TEXT = 1 }
                                                                                        >  6425  enum : uint { MCSC_TITLEBK = 2 }
                                                                                        >  6426  enum : uint { MCSC_TITLETEXT = 3 }
                                                                                        >  6427  enum : uint { MCSC_MONTHBK = 4 }
                                                                                        >  6428  enum : uint { MCSC_TRAILINGTEXT = 5 }
                                                                                        >  6429  
                                                                                        >  6430  enum : uint { MCM_SETTODAY = MCM_FIRST + 12 }
                                                                                        >  6431  // #define MonthCal_SetToday(hmc, pst) SNDMSG(hmc, MCM_SETTODAY, 0, (LPARAM)(pst
                                                                                        >  6432  
                                                                                        >  6433  enum : uint { MCM_GETTODAY = MCM_FIRST + 13 }
                                                                                        >  6434  // #define MonthCal_GetToday(hmc, pst) (BOOL)SNDMSG(hmc, MCM_GETTODAY, 0, (LPARA
                                                                                        >  6435  
                                                                                        >  6436  enum : uint { MCM_HITTEST = MCM_FIRST + 14 }
                                                                                        >  6437  // #define MonthCal_HitTest(hmc, pinfo) SNDMSG(hmc, MCM_HITTEST, 0, (LPARAM)(PMC
                                                                                        >  6438  
                                                                                        >  6439  struct _15 {
                                                                                        >  6440    UINT cbSize;
                                                                                        >  6441    POINT pt;
                                                                                        >  6442    UINT uHit;
                                                                                        >  6443    SYSTEMTIME st;
                                                                                        >  6444  }
                                                                                        >  6445  alias _15 MCHITTESTINFO;
                                                                                        >  6446  alias _15* PMCHITTESTINFO;
                                                                                        >  6447  
                                                                                        >  6448  enum : uint { MCHT_TITLE = 0x00010000 }
                                                                                        >  6449  enum : uint { MCHT_CALENDAR = 0x00020000 }
                                                                                        >  6450  enum : uint { MCHT_TODAYLINK = 0x00030000 }
                                                                                        >  6451  
                                                                                        >  6452  enum : uint { MCHT_NEXT = 0x01000000 }
                                                                                        >  6453  enum : uint { MCHT_PREV = 0x02000000 }
                                                                                        >  6454  
                                                                                        >  6455  enum : uint { MCHT_NOWHERE = 0x00000000 }
                                                                                        >  6456  
                                                                                        >  6457  enum : uint { MCHT_TITLEBK = MCHT_TITLE }
                                                                                        >  6458  enum : uint { MCHT_TITLEMONTH = MCHT_TITLE | 0x0001 }
                                                                                        >  6459  enum : uint { MCHT_TITLEYEAR = MCHT_TITLE | 0x0002 }
                                                                                        >  6460  enum : uint { MCHT_TITLEBTNNEXT = MCHT_TITLE | MCHT_NEXT | 0x0003 }
                                                                                        >  6461  enum : uint { MCHT_TITLEBTNPREV = MCHT_TITLE | MCHT_PREV | 0x0003 }
                                                                                        >  6462  
                                                                                        >  6463  enum : uint { MCHT_CALENDARBK = MCHT_CALENDAR }
                                                                                        >  6464  enum : uint { MCHT_CALENDARDATE = MCHT_CALENDAR | 0x0001 }
                                                                                        >  6465  enum : uint { MCHT_CALENDARDATENEXT = MCHT_CALENDARDATE | MCHT_NEXT }
                                                                                        >  6466  enum : uint { MCHT_CALENDARDATEPREV = MCHT_CALENDARDATE | MCHT_PREV }
                                                                                        >  6467  enum : uint { MCHT_CALENDARDAY = MCHT_CALENDAR | 0x0002 }
                                                                                        >  6468  enum : uint { MCHT_CALENDARWEEKNUM = MCHT_CALENDAR | 0x0003 }
                                                                                        >  6469  
                                                                                        >  6470  enum : uint { MCM_SETFIRSTDAYOFWEEK = MCM_FIRST + 15 }
                                                                                        >  6471  // #define MonthCal_SetFirstDayOfWeek(hmc, iDay) SNDMSG(hmc, MCM_SETFIRSTDAYOFWE
                                                                                        >  6472  
                                                                                        >  6473  enum : uint { MCM_GETFIRSTDAYOFWEEK = MCM_FIRST + 16 }
                                                                                        >  6474  // #define MonthCal_GetFirstDayOfWeek(hmc) (DWORD)SNDMSG(hmc, MCM_GETFIRSTDAYOFW
                                                                                        >  6475  
                                                                                        >  6476  enum : uint { MCM_GETRANGE = MCM_FIRST + 17 }
                                                                                        >  6477  // #define MonthCal_GetRange(hmc, rgst) (DWORD)SNDMSG(hmc, MCM_GETRANGE, 0, (LPA
                                                                                        >  6478  
                                                                                        >  6479  enum : uint { MCM_SETRANGE = MCM_FIRST + 18 }
                                                                                        >  6480  // #define MonthCal_SetRange(hmc, gd, rgst) (BOOL)SNDMSG(hmc, MCM_SETRANGE, (WPA
                                                                                        >  6481  
                                                                                        >  6482  enum : uint { MCM_GETMONTHDELTA = MCM_FIRST + 19 }
                                                                                        >  6483  // #define MonthCal_GetMonthDelta(hmc) (int)SNDMSG(hmc, MCM_GETMONTHDELTA, 0, 0)
                                                                                        >  6484  
                                                                                        >  6485  enum : uint { MCM_SETMONTHDELTA = MCM_FIRST + 20 }
                                                                                        >  6486  // #define MonthCal_SetMonthDelta(hmc, n) (int)SNDMSG(hmc, MCM_SETMONTHDELTA, n,
                                                                                        >  6487  
                                                                                        >  6488  enum : uint { MCM_GETMAXTODAYWIDTH = MCM_FIRST + 21 }
                                                                                        >  6489  // #define MonthCal_GetMaxTodayWidth(hmc) (DWORD)SNDMSG(hmc, MCM_GETMAXTODAYWIDT
                                                                                        >  6490  
                                                                                        >  6491  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6492  alias CCM_SETUNICODEFORMAT MCM_SETUNICODEFORMAT;
                                                                                        >  6493  // #define MonthCal_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), MCM_SE
                                                                                        >  6494  
                                                                                        >  6495  alias CCM_GETUNICODEFORMAT MCM_GETUNICODEFORMAT;
                                                                                        >  6496  // #define MonthCal_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), MCM_GETUNICODEFO
                                                                                        >  6497  // #endif
                                                                                        >  6498  
                                                                                        >  6499  struct tagNMSELCHANGE {
                                                                                        >  6500    NMHDR nmhdr;
                                                                                        >  6501  
                                                                                        >  6502    SYSTEMTIME stSelStart;
                                                                                        >  6503    SYSTEMTIME stSelEnd;
                                                                                        >  6504  }
                                                                                        >  6505  alias tagNMSELCHANGE NMSELCHANGE;
                                                                                        >  6506  alias tagNMSELCHANGE* LPNMSELCHANGE;
                                                                                        >  6507  
                                                                                        >  6508  enum : uint { MCN_SELCHANGE = MCN_FIRST + 1 }
                                                                                        >  6509  
                                                                                        >  6510  struct tagNMDAYSTATE {
                                                                                        >  6511    NMHDR nmhdr;
                                                                                        >  6512  
                                                                                        >  6513    SYSTEMTIME stStart;
                                                                                        >  6514    int cDayState;
                                                                                        >  6515    LPMONTHDAYSTATE prgDayState;
                                                                                        >  6516  }
                                                                                        >  6517  alias tagNMDAYSTATE NMDAYSTATE;
                                                                                        >  6518  alias tagNMDAYSTATE* LPNMDAYSTATE;
                                                                                        >  6519  
                                                                                        >  6520  enum : uint { MCN_GETDAYSTATE = MCN_FIRST + 3 }
                                                                                        >  6521  
                                                                                        >  6522  alias NMSELCHANGE NMSELECT;
                                                                                        >  6523  alias NMSELCHANGE* LPNMSELECT;
                                                                                        >  6524  
                                                                                        >  6525  enum : uint { MCN_SELECT = MCN_FIRST + 4 }
                                                                                        >  6526  
                                                                                        >  6527  enum : uint { MCS_DAYSTATE = 0x0001 }
                                                                                        >  6528  enum : uint { MCS_MULTISELECT = 0x0002 }
                                                                                        >  6529  enum : uint { MCS_WEEKNUMBERS = 0x0004 }
                                                                                        >  6530  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6531  enum : uint { MCS_NOTODAYCIRCLE = 0x0008 }
                                                                                        >  6532  enum : uint { MCS_NOTODAY = 0x0010 }
                                                                                        >  6533  // #else
                                                                                        >  6534  // #...
                                                                                        >  6535  // #endif
                                                                                        >  6536  
                                                                                        >  6537  enum : uint { GMR_VISIBLE = 0 }
                                                                                        >  6538  enum : uint { GMR_DAYSTATE = 1 }
                                                                                        >  6539  
                                                                                        >  6540  // #endif // _WIN32
                                                                                        >  6541  // #endif // NOMONTHCAL
                                                                                        >  6542  
                                                                                        >  6543  // #ifndef NODATETIMEPICK
                                                                                        >  6544  // #ifdef _WIN32
                                                                                        >  6545  
                                                                                        >  6546  const wchar[] DATETIMEPICK_CLASSW = "SysDateTimePick32";
                                                                                        >  6547  const char[] DATETIMEPICK_CLASSA = "SysDateTimePick32";
                                                                                        >  6548  
                                                                                        >  6549  // #ifdef UNICODE
                                                                                        >  6550  // #...
                                                                                        >  6551  // #else
                                                                                        >  6552  alias DATETIMEPICK_CLASSA DATETIMEPICK_CLASS;
                                                                                        >  6553  // #endif
                                                                                        >  6554  
                                                                                        >  6555  enum : uint { DTM_FIRST = 0x1000 }
                                                                                        >  6556  
                                                                                        >  6557  enum : uint { DTM_GETSYSTEMTIME = DTM_FIRST + 1 }
                                                                                        >  6558  // #define DateTime_GetSystemtime(hdp, pst) (DWORD)SNDMSG(hdp, DTM_GETSYSTEMTIME
                                                                                        >  6559  
                                                                                        >  6560  enum : uint { DTM_SETSYSTEMTIME = DTM_FIRST + 2 }
                                                                                        >  6561  // #define DateTime_SetSystemtime(hdp, gd, pst) (BOOL)SNDMSG(hdp, DTM_SETSYSTEMT
                                                                                        >  6562  
                                                                                        >  6563  enum : uint { DTM_GETRANGE = DTM_FIRST + 3 }
                                                                                        >  6564  // #define DateTime_GetRange(hdp, rgst) (DWORD)SNDMSG(hdp, DTM_GETRANGE, 0, (LPA
                                                                                        >  6565  
                                                                                        >  6566  enum : uint { DTM_SETRANGE = DTM_FIRST + 4 }
                                                                                        >  6567  // #define DateTime_SetRange(hdp, gd, rgst) (BOOL)SNDMSG(hdp, DTM_SETRANGE, (WPA
                                                                                        >  6568  
                                                                                        >  6569  enum : uint { DTM_SETFORMATA = DTM_FIRST + 5 }
                                                                                        >  6570  enum : uint { DTM_SETFORMATW = DTM_FIRST + 50 }
                                                                                        >  6571  
                                                                                        >  6572  // #ifdef UNICODE
                                                                                        >  6573  // #...
                                                                                        >  6574  // #else
                                                                                        >  6575  alias DTM_SETFORMATA DTM_SETFORMAT;
                                                                                        >  6576  // #endif
                                                                                        >  6577  
                                                                                        >  6578  // #define DateTime_SetFormat(hdp, sz) (BOOL)SNDMSG(hdp, DTM_SETFORMAT, 0, (LPAR
                                                                                        >  6579  
                                                                                        >  6580  enum : uint { DTM_SETMCCOLOR = DTM_FIRST + 6 }
                                                                                        >  6581  // #define DateTime_SetMonthCalColor(hdp, iColor, clr) SNDMSG(hdp, DTM_SETMCCOLO
                                                                                        >  6582  
                                                                                        >  6583  enum : uint { DTM_GETMCCOLOR = DTM_FIRST + 7 }
                                                                                        >  6584  // #define DateTime_GetMonthCalColor(hdp, iColor) SNDMSG(hdp, DTM_GETMCCOLOR, iC
                                                                                        >  6585  
                                                                                        >  6586  enum : uint { DTM_GETMONTHCAL = DTM_FIRST + 8 }
                                                                                        >  6587  // #define DateTime_GetMonthCal(hdp) (HWND)SNDMSG(hdp, DTM_GETMONTHCAL, 0, 0)
                                                                                        >  6588  
                                                                                        >  6589  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6590  
                                                                                        >  6591  enum : uint { DTM_SETMCFONT = DTM_FIRST + 9 }
                                                                                        >  6592  // #define DateTime_SetMonthCalFont(hdp, hfont, fRedraw) SNDMSG(hdp, DTM_SETMCFO
                                                                                        >  6593  
                                                                                        >  6594  enum : uint { DTM_GETMCFONT = DTM_FIRST + 10 }
                                                                                        >  6595  // #define DateTime_GetMonthCalFont(hdp) SNDMSG(hdp, DTM_GETMCFONT, 0, 0)
                                                                                        >  6596  
                                                                                        >  6597  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  6598  
                                                                                        >  6599  enum : uint { DTS_UPDOWN = 0x0001 }
                                                                                        >  6600  enum : uint { DTS_SHOWNONE = 0x0002 }
                                                                                        >  6601  enum : uint { DTS_SHORTDATEFORMAT = 0x0000 }
                                                                                        >  6602  enum : uint { DTS_LONGDATEFORMAT = 0x0004 }
                                                                                        >  6603  // #if (_WIN32_IE >= 0x500)
                                                                                        >  6604  enum : uint { DTS_SHORTDATECENTURYFORMAT = 0x000C }
                                                                                        >  6605  // #endif // (_WIN32_IE >= 0x500)
                                                                                        >  6606  enum : uint { DTS_TIMEFORMAT = 0x0009 }
                                                                                        >  6607  enum : uint { DTS_APPCANPARSE = 0x0010 }
                                                                                        >  6608  enum : uint { DTS_RIGHTALIGN = 0x0020 }
                                                                                        >  6609  
                                                                                        >  6610  enum : uint { DTN_DATETIMECHANGE = DTN_FIRST + 1 }
                                                                                        >  6611  struct tagNMDATETIMECHANGE {
                                                                                        >  6612    NMHDR nmhdr;
                                                                                        >  6613    DWORD dwFlags;
                                                                                        >  6614    SYSTEMTIME st;
                                                                                        >  6615  }
                                                                                        >  6616  alias tagNMDATETIMECHANGE NMDATETIMECHANGE;
                                                                                        >  6617  alias tagNMDATETIMECHANGE* LPNMDATETIMECHANGE;
                                                                                        >  6618  
                                                                                        >  6619  enum : uint { DTN_USERSTRINGA = DTN_FIRST + 2 }
                                                                                        >  6620  enum : uint { DTN_USERSTRINGW = DTN_FIRST + 15 }
                                                                                        >  6621  struct tagNMDATETIMESTRINGA {
                                                                                        >  6622    NMHDR nmhdr;
                                                                                        >  6623    LPCSTR pszUserString;
                                                                                        >  6624    SYSTEMTIME st;
                                                                                        >  6625    DWORD dwFlags;
                                                                                        >  6626  }
                                                                                        >  6627  alias tagNMDATETIMESTRINGA NMDATETIMESTRINGA;
                                                                                        >  6628  alias tagNMDATETIMESTRINGA* LPNMDATETIMESTRINGA;
                                                                                        >  6629  
                                                                                        >  6630  struct tagNMDATETIMESTRINGW {
                                                                                        >  6631    NMHDR nmhdr;
                                                                                        >  6632    LPCWSTR pszUserString;
                                                                                        >  6633    SYSTEMTIME st;
                                                                                        >  6634    DWORD dwFlags;
                                                                                        >  6635  }
                                                                                        >  6636  alias tagNMDATETIMESTRINGW NMDATETIMESTRINGW;
                                                                                        >  6637  alias tagNMDATETIMESTRINGW* LPNMDATETIMESTRINGW;
                                                                                        >  6638  
                                                                                        >  6639  // #ifdef UNICODE
                                                                                        >  6640  // #...
                                                                                        >  6641  // #...
                                                                                        >  6642  // #...
                                                                                        >  6643  // #else
                                                                                        >  6644  alias DTN_USERSTRINGA DTN_USERSTRING;
                                                                                        >  6645  alias NMDATETIMESTRINGA NMDATETIMESTRING;
                                                                                        >  6646  alias LPNMDATETIMESTRINGA LPNMDATETIMESTRING;
                                                                                        >  6647  // #endif
                                                                                        >  6648  
                                                                                        >  6649  enum : uint { DTN_WMKEYDOWNA = DTN_FIRST + 3 }
                                                                                        >  6650  enum : uint { DTN_WMKEYDOWNW = DTN_FIRST + 16 }
                                                                                        >  6651  struct tagNMDATETIMEWMKEYDOWNA {
                                                                                        >  6652    NMHDR nmhdr;
                                                                                        >  6653    int nVirtKey;
                                                                                        >  6654    LPCSTR pszFormat;
                                                                                        >  6655    SYSTEMTIME st;
                                                                                        >  6656  }
                                                                                        >  6657  alias tagNMDATETIMEWMKEYDOWNA NMDATETIMEWMKEYDOWNA;
                                                                                        >  6658  alias tagNMDATETIMEWMKEYDOWNA* LPNMDATETIMEWMKEYDOWNA;
                                                                                        >  6659  
                                                                                        >  6660  struct tagNMDATETIMEWMKEYDOWNW {
                                                                                        >  6661    NMHDR nmhdr;
                                                                                        >  6662    int nVirtKey;
                                                                                        >  6663    LPCWSTR pszFormat;
                                                                                        >  6664    SYSTEMTIME st;
                                                                                        >  6665  }
                                                                                        >  6666  alias tagNMDATETIMEWMKEYDOWNW NMDATETIMEWMKEYDOWNW;
                                                                                        >  6667  alias tagNMDATETIMEWMKEYDOWNW* LPNMDATETIMEWMKEYDOWNW;
                                                                                        >  6668  
                                                                                        >  6669  // #ifdef UNICODE
                                                                                        >  6670  // #...
                                                                                        >  6671  // #...
                                                                                        >  6672  // #...
                                                                                        >  6673  // #else
                                                                                        >  6674  alias DTN_WMKEYDOWNA DTN_WMKEYDOWN;
                                                                                        >  6675  alias NMDATETIMEWMKEYDOWNA NMDATETIMEWMKEYDOWN;
                                                                                        >  6676  alias LPNMDATETIMEWMKEYDOWNA LPNMDATETIMEWMKEYDOWN;
                                                                                        >  6677  // #endif
                                                                                        >  6678  
                                                                                        >  6679  enum : uint { DTN_FORMATA = DTN_FIRST + 4 }
                                                                                        >  6680  enum : uint { DTN_FORMATW = DTN_FIRST + 17 }
                                                                                        >  6681  struct tagNMDATETIMEFORMATA {
                                                                                        >  6682    NMHDR nmhdr;
                                                                                        >  6683    LPCSTR pszFormat;
                                                                                        >  6684    SYSTEMTIME st;
                                                                                        >  6685    LPCSTR pszDisplay;
                                                                                        >  6686    CHAR szDisplay[64];
                                                                                        >  6687  }
                                                                                        >  6688  alias tagNMDATETIMEFORMATA NMDATETIMEFORMATA;
                                                                                        >  6689  alias tagNMDATETIMEFORMATA* LPNMDATETIMEFORMATA;
                                                                                        >  6690  
                                                                                        >  6691  struct tagNMDATETIMEFORMATW {
                                                                                        >  6692    NMHDR nmhdr;
                                                                                        >  6693    LPCWSTR pszFormat;
                                                                                        >  6694    SYSTEMTIME st;
                                                                                        >  6695    LPCWSTR pszDisplay;
                                                                                        >  6696    WCHAR szDisplay[64];
                                                                                        >  6697  }
                                                                                        >  6698  alias tagNMDATETIMEFORMATW NMDATETIMEFORMATW;
                                                                                        >  6699  alias tagNMDATETIMEFORMATW* LPNMDATETIMEFORMATW;
                                                                                        >  6700  
                                                                                        >  6701  // #ifdef UNICODE
                                                                                        >  6702  // #...
                                                                                        >  6703  // #...
                                                                                        >  6704  // #...
                                                                                        >  6705  // #else
                                                                                        >  6706  alias DTN_FORMATA DTN_FORMAT;
                                                                                        >  6707  alias NMDATETIMEFORMATA NMDATETIMEFORMAT;
                                                                                        >  6708  alias LPNMDATETIMEFORMATA LPNMDATETIMEFORMAT;
                                                                                        >  6709  // #endif
                                                                                        >  6710  
                                                                                        >  6711  enum : uint { DTN_FORMATQUERYA = DTN_FIRST + 5 }
                                                                                        >  6712  enum : uint { DTN_FORMATQUERYW = DTN_FIRST + 18 }
                                                                                        >  6713  struct tagNMDATETIMEFORMATQUERYA {
                                                                                        >  6714    NMHDR nmhdr;
                                                                                        >  6715    LPCSTR pszFormat;
                                                                                        >  6716    SIZE szMax;
                                                                                        >  6717  }
                                                                                        >  6718  alias tagNMDATETIMEFORMATQUERYA NMDATETIMEFORMATQUERYA;
                                                                                        >  6719  alias tagNMDATETIMEFORMATQUERYA* LPNMDATETIMEFORMATQUERYA;
                                                                                        >  6720  
                                                                                        >  6721  struct tagNMDATETIMEFORMATQUERYW {
                                                                                        >  6722    NMHDR nmhdr;
                                                                                        >  6723    LPCWSTR pszFormat;
                                                                                        >  6724    SIZE szMax;
                                                                                        >  6725  }
                                                                                        >  6726  alias tagNMDATETIMEFORMATQUERYW NMDATETIMEFORMATQUERYW;
                                                                                        >  6727  alias tagNMDATETIMEFORMATQUERYW* LPNMDATETIMEFORMATQUERYW;
                                                                                        >  6728  
                                                                                        >  6729  // #ifdef UNICODE
                                                                                        >  6730  // #...
                                                                                        >  6731  // #...
                                                                                        >  6732  // #...
                                                                                        >  6733  // #else
                                                                                        >  6734  alias DTN_FORMATQUERYA DTN_FORMATQUERY;
                                                                                        >  6735  alias NMDATETIMEFORMATQUERYA NMDATETIMEFORMATQUERY;
                                                                                        >  6736  alias LPNMDATETIMEFORMATQUERYA LPNMDATETIMEFORMATQUERY;
                                                                                        >  6737  // #endif
                                                                                        >  6738  
                                                                                        >  6739  enum : uint { DTN_DROPDOWN = DTN_FIRST + 6 }
                                                                                        >  6740  enum : uint { DTN_CLOSEUP = DTN_FIRST + 7 }
                                                                                        >  6741  
                                                                                        >  6742  enum : uint { GDTR_MIN = 0x0001 }
                                                                                        >  6743  enum : uint { GDTR_MAX = 0x0002 }
                                                                                        >  6744  
                                                                                        >  6745  enum { GDT_ERROR = -1 }
                                                                                        >  6746  enum : uint { GDT_VALID = 0 }
                                                                                        >  6747  enum : uint { GDT_NONE = 1 }
                                                                                        >  6748  
                                                                                        >  6749  // #endif // _WIN32
                                                                                        >  6750  // #endif // NODATETIMEPICK
                                                                                        >  6751  
                                                                                        >  6752  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  6753  
                                                                                        >  6754  // #ifndef NOIPADDRESS
                                                                                        >  6755  
                                                                                        >  6756  enum : uint { IPM_CLEARADDRESS = WM_USER+100 }
                                                                                        >  6757  enum : uint { IPM_SETADDRESS = WM_USER+101 }
                                                                                        >  6758  enum : uint { IPM_GETADDRESS = WM_USER+102 }
                                                                                        >  6759  enum : uint { IPM_SETRANGE = WM_USER+103 }
                                                                                        >  6760  enum : uint { IPM_SETFOCUS = WM_USER+104 }
                                                                                        >  6761  enum : uint { IPM_ISBLANK = WM_USER+105 }
                                                                                        >  6762  
                                                                                        >  6763  const wchar[] WC_IPADDRESSW = "SysIPAddress32";
                                                                                        >  6764  const char[] WC_IPADDRESSA = "SysIPAddress32";
                                                                                        >  6765  
                                                                                        >  6766  // #ifdef UNICODE
                                                                                        >  6767  // #...
                                                                                        >  6768  // #else
                                                                                        >  6769  alias WC_IPADDRESSA WC_IPADDRESS;
                                                                                        >  6770  // #endif
                                                                                        >  6771  
                                                                                        >  6772  enum : uint { IPN_FIELDCHANGED = IPN_FIRST - 0 }
                                                                                        >  6773  struct tagNMIPADDRESS {
                                                                                        >  6774    NMHDR hdr;
                                                                                        >  6775    int iField;
                                                                                        >  6776    int iValue;
                                                                                        >  6777  }
                                                                                        >  6778  alias tagNMIPADDRESS NMIPADDRESS;
                                                                                        >  6779  alias tagNMIPADDRESS* LPNMIPADDRESS;
                                                                                        >  6780  
                                                                                        >  6781  // #define MAKEIPRANGE(low, high) ((LPARAM)(WORD)(((BYTE)(high) << 8) + (BYTE)(l
                                                                                        >  6782  
                                                                                        >  6783  // #define MAKEIPADDRESS(b1,b2,b3,b4) ((LPARAM)(((DWORD)(b1)<<24)+((DWORD)(b2)<<
                                                                                        >  6784  
                                                                                        >  6785  // #define FIRST_IPADDRESS(x) ((x>>24) & 0xff)
                                                                                        >  6786  // #define SECOND_IPADDRESS(x) ((x>>16) & 0xff)
                                                                                        >  6787  // #define THIRD_IPADDRESS(x) ((x>>8) & 0xff)
                                                                                        >  6788  // #define FOURTH_IPADDRESS(x) (x & 0xff)
                                                                                        >  6789  
                                                                                        >  6790  // #endif // NOIPADDRESS
                                                                                        >  6791  
                                                                                        >  6792  // #ifndef NOPAGESCROLLER
                                                                                        >  6793  
                                                                                        >  6794  const wchar[] WC_PAGESCROLLERW = "SysPager";
                                                                                        >  6795  const char[] WC_PAGESCROLLERA = "SysPager";
                                                                                        >  6796  
                                                                                        >  6797  // #ifdef UNICODE
                                                                                        >  6798  // #...
                                                                                        >  6799  // #else
                                                                                        >  6800  alias WC_PAGESCROLLERA WC_PAGESCROLLER;
                                                                                        >  6801  // #endif
                                                                                        >  6802  
                                                                                        >  6803  enum : uint { PGS_VERT = 0x00000000 }
                                                                                        >  6804  enum : uint { PGS_HORZ = 0x00000001 }
                                                                                        >  6805  enum : uint { PGS_AUTOSCROLL = 0x00000002 }
                                                                                        >  6806  enum : uint { PGS_DRAGNDROP = 0x00000004 }
                                                                                        >  6807  
                                                                                        >  6808  enum : uint { PGF_INVISIBLE = 0 }
                                                                                        >  6809  enum : uint { PGF_NORMAL = 1 }
                                                                                        >  6810  enum : uint { PGF_GRAYED = 2 }
                                                                                        >  6811  enum : uint { PGF_DEPRESSED = 4 }
                                                                                        >  6812  enum : uint { PGF_HOT = 8 }
                                                                                        >  6813  
                                                                                        >  6814  enum : uint { PGB_TOPORLEFT = 0 }
                                                                                        >  6815  enum : uint { PGB_BOTTOMORRIGHT = 1 }
                                                                                        >  6816  
                                                                                        >  6817  enum : uint { PGM_SETCHILD = PGM_FIRST + 1 }
                                                                                        >  6818  // #define Pager_SetChild(hwnd, hwndChild) (void)SNDMSG((hwnd), PGM_SETCHILD, 0,
                                                                                        >  6819  
                                                                                        >  6820  enum : uint { PGM_RECALCSIZE = PGM_FIRST + 2 }
                                                                                        >  6821  // #define Pager_RecalcSize(hwnd) (void)SNDMSG((hwnd), PGM_RECALCSIZE, 0, 0)
                                                                                        >  6822  
                                                                                        >  6823  enum : uint { PGM_FORWARDMOUSE = PGM_FIRST + 3 }
                                                                                        >  6824  // #define Pager_ForwardMouse(hwnd, bForward) (void)SNDMSG((hwnd), PGM_FORWARDMO
                                                                                        >  6825  
                                                                                        >  6826  enum : uint { PGM_SETBKCOLOR = PGM_FIRST + 4 }
                                                                                        >  6827  // #define Pager_SetBkColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), PGM_SETBKCOLOR, 
                                                                                        >  6828  
                                                                                        >  6829  enum : uint { PGM_GETBKCOLOR = PGM_FIRST + 5 }
                                                                                        >  6830  // #define Pager_GetBkColor(hwnd) (COLORREF)SNDMSG((hwnd), PGM_GETBKCOLOR, 0, 0)
                                                                                        >  6831  
                                                                                        >  6832  enum : uint { PGM_SETBORDER = PGM_FIRST + 6 }
                                                                                        >  6833  // #define Pager_SetBorder(hwnd, iBorder) (int)SNDMSG((hwnd), PGM_SETBORDER, 0, 
                                                                                        >  6834  
                                                                                        >  6835  enum : uint { PGM_GETBORDER = PGM_FIRST + 7 }
                                                                                        >  6836  // #define Pager_GetBorder(hwnd) (int)SNDMSG((hwnd), PGM_GETBORDER, 0, 0)
                                                                                        >  6837  
                                                                                        >  6838  enum : uint { PGM_SETPOS = PGM_FIRST + 8 }
                                                                                        >  6839  // #define Pager_SetPos(hwnd, iPos) (int)SNDMSG((hwnd), PGM_SETPOS, 0, (LPARAM)(
                                                                                        >  6840  
                                                                                        >  6841  enum : uint { PGM_GETPOS = PGM_FIRST + 9 }
                                                                                        >  6842  // #define Pager_GetPos(hwnd) (int)SNDMSG((hwnd), PGM_GETPOS, 0, 0)
                                                                                        >  6843  
                                                                                        >  6844  enum : uint { PGM_SETBUTTONSIZE = PGM_FIRST + 10 }
                                                                                        >  6845  // #define Pager_SetButtonSize(hwnd, iSize) (int)SNDMSG((hwnd), PGM_SETBUTTONSIZ
                                                                                        >  6846  
                                                                                        >  6847  enum : uint { PGM_GETBUTTONSIZE = PGM_FIRST + 11 }
                                                                                        >  6848  // #define Pager_GetButtonSize(hwnd) (int)SNDMSG((hwnd), PGM_GETBUTTONSIZE, 0,0)
                                                                                        >  6849  
                                                                                        >  6850  enum : uint { PGM_GETBUTTONSTATE = PGM_FIRST + 12 }
                                                                                        >  6851  // #define Pager_GetButtonState(hwnd, iButton) (DWORD)SNDMSG((hwnd), PGM_GETBUTT
                                                                                        >  6852  
                                                                                        >  6853  alias CCM_GETDROPTARGET PGM_GETDROPTARGET;
                                                                                        >  6854  // #define Pager_GetDropTarget(hwnd, ppdt) (void)SNDMSG((hwnd), PGM_GETDROPTARGE
                                                                                        >  6855  
                                                                                        >  6856  enum : uint { PGN_SCROLL = PGN_FIRST-1 }
                                                                                        >  6857  
                                                                                        >  6858  enum : uint { PGF_SCROLLUP = 1 }
                                                                                        >  6859  enum : uint { PGF_SCROLLDOWN = 2 }
                                                                                        >  6860  enum : uint { PGF_SCROLLLEFT = 4 }
                                                                                        >  6861  enum : uint { PGF_SCROLLRIGHT = 8 }
                                                                                        >  6862  
                                                                                        >  6863  enum : uint { PGK_SHIFT = 1 }
                                                                                        >  6864  enum : uint { PGK_CONTROL = 2 }
                                                                                        >  6865  enum : uint { PGK_MENU = 4 }
                                                                                        >  6866  
                                                                                        >  6867  // #ifdef _WIN32
                                                                                        >  6868  align(1):
                                                                                        >  6869  // #endif
                                                                                        >  6870  
                                                                                        >  6871  struct _16 {
                                                                                        >  6872    NMHDR hdr;
                                                                                        >  6873    WORD fwKeys;
                                                                                        >  6874    RECT rcParent;
                                                                                        >  6875    int iDir;
                                                                                        >  6876    int iXpos;
                                                                                        >  6877    int iYpos;
                                                                                        >  6878    int iScroll;
                                                                                        >  6879  }
                                                                                        >  6880  alias _16 NMPGSCROLL;
                                                                                        >  6881  alias _16* LPNMPGSCROLL;
                                                                                        >  6882  
                                                                                        >  6883  // #ifdef _WIN32
                                                                                        >  6884  align:
                                                                                        >  6885  // #endif
                                                                                        >  6886  
                                                                                        >  6887  enum : uint { PGN_CALCSIZE = PGN_FIRST-2 }
                                                                                        >  6888  
                                                                                        >  6889  enum : uint { PGF_CALCWIDTH = 1 }
                                                                                        >  6890  enum : uint { PGF_CALCHEIGHT = 2 }
                                                                                        >  6891  
                                                                                        >  6892  struct _17 {
                                                                                        >  6893    NMHDR hdr;
                                                                                        >  6894    DWORD dwFlag;
                                                                                        >  6895    int iWidth;
                                                                                        >  6896    int iHeight;
                                                                                        >  6897  }
                                                                                        >  6898  alias _17 NMPGCALCSIZE;
                                                                                        >  6899  alias _17* LPNMPGCALCSIZE;
                                                                                        >  6900  
                                                                                        >  6901  enum : uint { PGN_HOTITEMCHANGE = PGN_FIRST-3 }
                                                                                        >  6902  
                                                                                        >  6903  struct tagNMPGHOTITEM {
                                                                                        >  6904    NMHDR hdr;
                                                                                        >  6905    int idOld;
                                                                                        >  6906    int idNew;
                                                                                        >  6907    DWORD dwFlags;
                                                                                        >  6908  }
                                                                                        >  6909  alias tagNMPGHOTITEM NMPGHOTITEM;
                                                                                        >  6910  alias tagNMPGHOTITEM* LPNMPGHOTITEM;
                                                                                        >  6911  
                                                                                        >  6912  // #endif // NOPAGESCROLLER
                                                                                        >  6913  
                                                                                        >  6914  // #ifndef NONATIVEFONTCTL
                                                                                        >  6915  
                                                                                        >  6916  const wchar[] WC_NATIVEFONTCTLW = "NativeFontCtl";
                                                                                        >  6917  const char[] WC_NATIVEFONTCTLA = "NativeFontCtl";
                                                                                        >  6918  
                                                                                        >  6919  // #ifdef UNICODE
                                                                                        >  6920  // #...
                                                                                        >  6921  // #else
                                                                                        >  6922  alias WC_NATIVEFONTCTLA WC_NATIVEFONTCTL;
                                                                                        >  6923  // #endif
                                                                                        >  6924  
                                                                                        >  6925  enum : uint { NFS_EDIT = 0x0001 }
                                                                                        >  6926  enum : uint { NFS_STATIC = 0x0002 }
                                                                                        >  6927  enum : uint { NFS_LISTCOMBO = 0x0004 }
                                                                                        >  6928  enum : uint { NFS_BUTTON = 0x0008 }
                                                                                        >  6929  enum : uint { NFS_ALL = 0x0010 }
                                                                                        >  6930  enum : uint { NFS_USEFONTASSOC = 0x0020 }
                                                                                        >  6931  
                                                                                        >  6932  // #endif // NONATIVEFONTCTL
                                                                                        >  6933  
                                                                                        >  6934  // #ifndef NOBUTTON
                                                                                        >  6935  
                                                                                        >  6936  // #ifdef _WIN32
                                                                                        >  6937  
                                                                                        >  6938  const char[] WC_BUTTONA = "Button";
                                                                                        >  6939  const wchar[] WC_BUTTONW = "Button";
                                                                                        >  6940  
                                                                                        >  6941  // #ifdef UNICODE
                                                                                        >  6942  // #...
                                                                                        >  6943  // #else
                                                                                        >  6944  alias WC_BUTTONA WC_BUTTON;
                                                                                        >  6945  // #endif
                                                                                        >  6946  
                                                                                        >  6947  // #else
                                                                                        >  6948  // #...
                                                                                        >  6949  // #endif
                                                                                        >  6950  
                                                                                        >  6951  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  6952  enum : uint { BUTTON_IMAGELIST_ALIGN_LEFT = 0 }
                                                                                        >  6953  enum : uint { BUTTON_IMAGELIST_ALIGN_RIGHT = 1 }
                                                                                        >  6954  enum : uint { BUTTON_IMAGELIST_ALIGN_TOP = 2 }
                                                                                        >  6955  enum : uint { BUTTON_IMAGELIST_ALIGN_BOTTOM = 3 }
                                                                                        >  6956  enum : uint { BUTTON_IMAGELIST_ALIGN_CENTER = 4 }
                                                                                        >  6957  
                                                                                        >  6958  struct _18 {
                                                                                        >  6959    HIMAGELIST himl;
                                                                                        >  6960    RECT margin;
                                                                                        >  6961    UINT uAlign;
                                                                                        >  6962  }
                                                                                        >  6963  alias _18 BUTTON_IMAGELIST;
                                                                                        >  6964  alias _18* PBUTTON_IMAGELIST;
                                                                                        >  6965  
                                                                                        >  6966  enum : uint { BCM_GETIDEALSIZE = BCM_FIRST + 0x0001 }
                                                                                        >  6967  // #define Button_GetIdealSize(hwnd, psize) (BOOL)SNDMSG((hwnd), BCM_GETIDEALSIZ
                                                                                        >  6968  
                                                                                        >  6969  enum : uint { BCM_SETIMAGELIST = BCM_FIRST + 0x0002 }
                                                                                        >  6970  // #define Button_SetImageList(hwnd, pbuttonImagelist) (BOOL)SNDMSG((hwnd), BCM_
                                                                                        >  6971  
                                                                                        >  6972  enum : uint { BCM_GETIMAGELIST = BCM_FIRST + 0x0003 }
                                                                                        >  6973  // #define Button_GetImageList(hwnd, pbuttonImagelist) (BOOL)SNDMSG((hwnd), BCM_
                                                                                        >  6974  
                                                                                        >  6975  enum : uint { BCM_SETTEXTMARGIN = BCM_FIRST + 0x0004 }
                                                                                        >  6976  // #define Button_SetTextMargin(hwnd, pmargin) (BOOL)SNDMSG((hwnd), BCM_SETTEXTM
                                                                                        >  6977  enum : uint { BCM_GETTEXTMARGIN = BCM_FIRST + 0x0005 }
                                                                                        >  6978  // #define Button_GetTextMargin(hwnd, pmargin) (BOOL)SNDMSG((hwnd), BCM_GETTEXTM
                                                                                        >  6979  
                                                                                        >  6980  struct tagNMBCHOTITEM {
                                                                                        >  6981    NMHDR hdr;
                                                                                        >  6982    DWORD dwFlags;
                                                                                        >  6983  }
                                                                                        >  6984  alias tagNMBCHOTITEM NMBCHOTITEM;
                                                                                        >  6985  alias tagNMBCHOTITEM* LPNMBCHOTITEM;
                                                                                        >  6986  
                                                                                        >  6987  enum : uint { BCN_HOTITEMCHANGE = BCN_FIRST + 0x0001 }
                                                                                        >  6988  
                                                                                        >  6989  enum : uint { BST_HOT = 0x0200 }
                                                                                        >  6990  
                                                                                        >  6991  // #endif
                                                                                        >  6992  
                                                                                        >  6993  // #endif // NOBUTTON
                                                                                        >  6994  
                                                                                        >  6995  // #ifndef NOSTATIC
                                                                                        >  6996  
                                                                                        >  6997  // #ifdef _WIN32
                                                                                        >  6998  
                                                                                        >  6999  const char[] WC_STATICA = "Static";
                                                                                        >  7000  const wchar[] WC_STATICW = "Static";
                                                                                        >  7001  
                                                                                        >  7002  // #ifdef UNICODE
                                                                                        >  7003  // #...
                                                                                        >  7004  // #else
                                                                                        >  7005  alias WC_STATICA WC_STATIC;
                                                                                        >  7006  // #endif
                                                                                        >  7007  
                                                                                        >  7008  // #else
                                                                                        >  7009  // #...
                                                                                        >  7010  // #endif
                                                                                        >  7011  
                                                                                        >  7012  // #endif // NOSTATIC
                                                                                        >  7013  
                                                                                        >  7014  // #ifndef NOEDIT
                                                                                        >  7015  
                                                                                        >  7016  // #ifdef _WIN32
                                                                                        >  7017  
                                                                                        >  7018  const char[] WC_EDITA = "Edit";
                                                                                        >  7019  const wchar[] WC_EDITW = "Edit";
                                                                                        >  7020  
                                                                                        >  7021  // #ifdef UNICODE
                                                                                        >  7022  // #...
                                                                                        >  7023  // #else
                                                                                        >  7024  alias WC_EDITA WC_EDIT;
                                                                                        >  7025  // #endif
                                                                                        >  7026  
                                                                                        >  7027  // #else
                                                                                        >  7028  // #...
                                                                                        >  7029  // #endif
                                                                                        >  7030  
                                                                                        >  7031  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  7032  enum : uint { EM_SETCUEBANNER = ECM_FIRST + 1 }
                                                                                        >  7033  // #define Edit_SetCueBannerText(hwnd, lpcwText) (BOOL)SNDMSG((hwnd), EM_SETCUEB
                                                                                        >  7034  enum : uint { EM_GETCUEBANNER = ECM_FIRST + 2 }
                                                                                        >  7035  // #define Edit_GetCueBannerText(hwnd, lpwText, cchText) (BOOL)SNDMSG((hwnd), EM
                                                                                        >  7036  
                                                                                        >  7037  struct _tagEDITBALLOONTIP {
                                                                                        >  7038    DWORD cbStruct;
                                                                                        >  7039    LPCWSTR pszTitle;
                                                                                        >  7040    LPCWSTR pszText;
                                                                                        >  7041    INT ttiIcon;
                                                                                        >  7042  }
                                                                                        >  7043  alias _tagEDITBALLOONTIP EDITBALLOONTIP;
                                                                                        >  7044  alias _tagEDITBALLOONTIP* PEDITBALLOONTIP;
                                                                                        >  7045  
                                                                                        >  7046  enum : uint { EM_SHOWBALLOONTIP = ECM_FIRST + 3 }
                                                                                        >  7047  // #define Edit_ShowBalloonTip(hwnd, peditballoontip) (BOOL)SNDMSG((hwnd), EM_SH
                                                                                        >  7048  enum : uint { EM_HIDEBALLOONTIP = ECM_FIRST + 4 }
                                                                                        >  7049  // #define Edit_HideBalloonTip(hwnd) (BOOL)SNDMSG((hwnd), EM_HIDEBALLOONTIP, 0, 
                                                                                        >  7050  // #endif
                                                                                        >  7051  
                                                                                        >  7052  // #endif // NOEDIT
                                                                                        >  7053  
                                                                                        >  7054  // #ifndef NOLISTBOX
                                                                                        >  7055  
                                                                                        >  7056  // #ifdef _WIN32
                                                                                        >  7057  
                                                                                        >  7058  const char[] WC_LISTBOXA = "ListBox";
                                                                                        >  7059  const wchar[] WC_LISTBOXW = "ListBox";
                                                                                        >  7060  
                                                                                        >  7061  // #ifdef UNICODE
                                                                                        >  7062  // #...
                                                                                        >  7063  // #else
                                                                                        >  7064  alias WC_LISTBOXA WC_LISTBOX;
                                                                                        >  7065  // #endif
                                                                                        >  7066  
                                                                                        >  7067  // #else
                                                                                        >  7068  // #...
                                                                                        >  7069  // #endif
                                                                                        >  7070  
                                                                                        >  7071  // #endif // NOLISTBOX
                                                                                        >  7072  
                                                                                        >  7073  // #ifndef NOCOMBOBOX
                                                                                        >  7074  
                                                                                        >  7075  // #ifdef _WIN32
                                                                                        >  7076  
                                                                                        >  7077  const char[] WC_COMBOBOXA = "ComboBox";
                                                                                        >  7078  const wchar[] WC_COMBOBOXW = "ComboBox";
                                                                                        >  7079  
                                                                                        >  7080  // #ifdef UNICODE
                                                                                        >  7081  // #...
                                                                                        >  7082  // #else
                                                                                        >  7083  alias WC_COMBOBOXA WC_COMBOBOX;
                                                                                        >  7084  // #endif
                                                                                        >  7085  
                                                                                        >  7086  // #else
                                                                                        >  7087  // #...
                                                                                        >  7088  // #endif
                                                                                        >  7089  
                                                                                        >  7090  // #endif // NOCOMBOBOX
                                                                                        >  7091  
                                                                                        >  7092  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  7093  
                                                                                        >  7094  enum : uint { CB_SETMINVISIBLE = CBM_FIRST + 1 }
                                                                                        >  7095  enum : uint { CB_GETMINVISIBLE = CBM_FIRST + 2 }
                                                                                        >  7096  
                                                                                        >  7097  // #define ComboBox_SetMinVisible(hwnd, iMinVisible) (BOOL)SNDMSG((hwnd), CB_SET
                                                                                        >  7098  
                                                                                        >  7099  // #define ComboBox_GetMinVisible(hwnd) (int)SNDMSG((hwnd), CB_GETMINVISIBLE, 0,
                                                                                        >  7100  
                                                                                        >  7101  // #endif
                                                                                        >  7102  
                                                                                        >  7103  // #ifndef NOSCROLLBAR
                                                                                        >  7104  
                                                                                        >  7105  // #ifdef _WIN32
                                                                                        >  7106  
                                                                                        >  7107  const char[] WC_SCROLLBARA = "ScrollBar";
                                                                                        >  7108  const wchar[] WC_SCROLLBARW = "ScrollBar";
                                                                                        >  7109  
                                                                                        >  7110  // #ifdef UNICODE
                                                                                        >  7111  // #...
                                                                                        >  7112  // #else
                                                                                        >  7113  alias WC_SCROLLBARA WC_SCROLLBAR;
                                                                                        >  7114  // #endif
                                                                                        >  7115  
                                                                                        >  7116  // #else
                                                                                        >  7117  // #...
                                                                                        >  7118  // #endif
                                                                                        >  7119  
                                                                                        >  7120  // #endif // NOSCROLLBAR
                                                                                        >  7121  
                                                                                        >  7122  // #ifdef _WIN32
                                                                                        >  7123  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  7124  
                                                                                        >  7125  enum { INVALID_LINK_INDEX = -1 }
                                                                                        >  7126  enum : uint { MAX_LINKID_TEXT = 48 }
                                                                                        >  7127  enum { L_MAX_URL_LENGTH = 2048 + 32 + 4 }
                                                                                        >  7128  
                                                                                        >  7129  const wchar[] WC_LINK = "SysLink";
                                                                                        >  7130  
                                                                                        >  7131  enum : uint { LWS_TRANSPARENT = 0x0001 }
                                                                                        >  7132  enum : uint { LWS_IGNORERETURN = 0x0002 }
                                                                                        >  7133  
                                                                                        >  7134  enum : uint { LIF_ITEMINDEX = 0x00000001 }
                                                                                        >  7135  enum : uint { LIF_STATE = 0x00000002 }
                                                                                        >  7136  enum : uint { LIF_ITEMID = 0x00000004 }
                                                                                        >  7137  enum : uint { LIF_URL = 0x00000008 }
                                                                                        >  7138  
                                                                                        >  7139  enum : uint { LIS_FOCUSED = 0x00000001 }
                                                                                        >  7140  enum : uint { LIS_ENABLED = 0x00000002 }
                                                                                        >  7141  enum : uint { LIS_VISITED = 0x00000004 }
                                                                                        >  7142  
                                                                                        >  7143  struct tagLITEM {
                                                                                        >  7144    UINT mask ;
                                                                                        >  7145    int iLink ;
                                                                                        >  7146    UINT state ;
                                                                                        >  7147    UINT stateMask ;
                                                                                        >  7148    WCHAR szID[MAX_LINKID_TEXT] ;
                                                                                        >  7149    WCHAR szUrl[L_MAX_URL_LENGTH] ;
                                                                                        >  7150  }
                                                                                        >  7151  alias tagLITEM LITEM;
                                                                                        >  7152  alias tagLITEM* PLITEM;
                                                                                        >  7153  
                                                                                        >  7154  struct tagLHITTESTINFO {
                                                                                        >  7155    POINT pt ;
                                                                                        >  7156    LITEM item ;
                                                                                        >  7157  }
                                                                                        >  7158  alias tagLHITTESTINFO LHITTESTINFO;
                                                                                        >  7159  alias tagLHITTESTINFO* PLHITTESTINFO;
                                                                                        >  7160  
                                                                                        >  7161  struct tagNMLINK {
                                                                                        >  7162    NMHDR hdr;
                                                                                        >  7163    LITEM item ;
                                                                                        >  7164  }
                                                                                        >  7165  alias tagNMLINK NMLINK;
                                                                                        >  7166  alias tagNMLINK* PNMLINK;
                                                                                        >  7167  
                                                                                        >  7168  enum : uint { LM_HITTEST = WM_USER+0x300 }
                                                                                        >  7169  enum : uint { LM_GETIDEALHEIGHT = WM_USER+0x301 }
                                                                                        >  7170  enum : uint { LM_SETITEM = WM_USER+0x302 }
                                                                                        >  7171  enum : uint { LM_GETITEM = WM_USER+0x303 }
                                                                                        >  7172  
                                                                                        >  7173  // #endif
                                                                                        >  7174  // #endif // _WIN32
                                                                                        >  7175  
                                                                                        >  7176  // #ifndef NOMUI
                                                                                        >  7177  extern(Windows) export void InitMUILanguage(LANGID uiLang);
                                                                                        >  7178  
                                                                                        >  7179  extern(Windows) export LANGID GetMUILanguage();
                                                                                        >  7180  // #endif  // NOMUI
                                                                                        >  7181  
                                                                                        >  7182  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  7183  
                                                                                        >  7184  // #ifdef _WIN32
                                                                                        >  7185  
                                                                                        >  7186  // #ifndef NOTRACKMOUSEEVENT
                                                                                        >  7187  
                                                                                        >  7188  // #ifndef WM_MOUSEHOVER
                                                                                        >  7189  // #...
                                                                                        >  7190  // #...
                                                                                        >  7191  // #endif
                                                                                        >  7192  
                                                                                        >  7193  // #ifndef TME_HOVER
                                                                                        >  7194  
                                                                                        >  7195  enum : uint { TME_HOVER = 0x00000001 }
                                                                                        >  7196  enum : uint { TME_LEAVE = 0x00000002 }
                                                                                        >  7197  // #if (WINVER >= 0x0500)
                                                                                        >  7198  enum : uint { TME_NONCLIENT = 0x00000010 }
                                                                                        >  7199  // #endif /* WINVER >= 0x0500 */
                                                                                        >  7200  enum : uint { TME_QUERY = 0x40000000 }
                                                                                        >  7201  enum : uint { TME_CANCEL = 0x80000000 }
                                                                                        >  7202  
                                                                                        >  7203  enum : uint { HOVER_DEFAULT = 0xFFFFFFFF }
                                                                                        >  7204  
                                                                                        >  7205  struct tagTRACKMOUSEEVENT {
                                                                                        >  7206    DWORD cbSize;
                                                                                        >  7207    DWORD dwFlags;
                                                                                        >  7208    HWND hwndTrack;
                                                                                        >  7209    DWORD dwHoverTime;
                                                                                        >  7210  }
                                                                                        >  7211  alias tagTRACKMOUSEEVENT TRACKMOUSEEVENT;
                                                                                        >  7212  alias tagTRACKMOUSEEVENT* LPTRACKMOUSEEVENT;
                                                                                        >  7213  
                                                                                        >  7214  // #endif // !TME_HOVER
                                                                                        >  7215  
                                                                                        >  7216  extern(Windows) export BOOL _TrackMouseEvent(
                                                                                        >  7217    LPTRACKMOUSEEVENT lpEventTrack);
                                                                                        >  7218  
                                                                                        >  7219  // #endif // !NOTRACKMOUSEEVENT
                                                                                        >  7220  
                                                                                        >  7221  // #if (_WIN32_IE >= 0x0400)
                                                                                        >  7222  
                                                                                        >  7223  // #ifndef NOFLATSBAPIS
                                                                                        >  7224  
                                                                                        >  7225  enum : uint { WSB_PROP_CYVSCROLL = 0x00000001 }
                                                                                        >  7226  enum : uint { WSB_PROP_CXHSCROLL = 0x00000002 }
                                                                                        >  7227  enum : uint { WSB_PROP_CYHSCROLL = 0x00000004 }
                                                                                        >  7228  enum : uint { WSB_PROP_CXVSCROLL = 0x00000008 }
                                                                                        >  7229  enum : uint { WSB_PROP_CXHTHUMB = 0x00000010 }
                                                                                        >  7230  enum : uint { WSB_PROP_CYVTHUMB = 0x00000020 }
                                                                                        >  7231  enum : uint { WSB_PROP_VBKGCOLOR = 0x00000040 }
                                                                                        >  7232  enum : uint { WSB_PROP_HBKGCOLOR = 0x00000080 }
                                                                                        >  7233  enum : uint { WSB_PROP_VSTYLE = 0x00000100 }
                                                                                        >  7234  enum : uint { WSB_PROP_HSTYLE = 0x00000200 }
                                                                                        >  7235  enum : uint { WSB_PROP_WINSTYLE = 0x00000400 }
                                                                                        >  7236  enum : uint { WSB_PROP_PALETTE = 0x00000800 }
                                                                                        >  7237  enum : uint { WSB_PROP_MASK = 0x00000FFF }
                                                                                        >  7238  
                                                                                        >  7239  enum : uint { FSB_FLAT_MODE = 2 }
                                                                                        >  7240  enum : uint { FSB_ENCARTA_MODE = 1 }
                                                                                        >  7241  enum : uint { FSB_REGULAR_MODE = 0 }
                                                                                        >  7242  
                                                                                        >  7243  extern(Windows) export BOOL FlatSB_EnableScrollBar(HWND, int, UINT);
                                                                                        >  7244  extern(Windows) export BOOL FlatSB_ShowScrollBar(HWND, int code, BOOL);
                                                                                        >  7245  
                                                                                        >  7246  extern(Windows) export BOOL FlatSB_GetScrollRange(HWND, int code, LPINT, LPINT);
                                                                                        >  7247  extern(Windows) export BOOL FlatSB_GetScrollInfo(HWND, int code, LPSCROLLINFO);
                                                                                        >  7248  
                                                                                        >  7249  extern(Windows) export int FlatSB_GetScrollPos(HWND, int code);
                                                                                        >  7250  
                                                                                        >  7251  extern(Windows) export BOOL FlatSB_GetScrollProp(HWND, int propIndex, LPINT);
                                                                                        >  7252  // #ifdef _WIN64
                                                                                        >  7253  // ...
                                                                                        >  7254  // #else
                                                                                        >  7255  alias FlatSB_GetScrollProp FlatSB_GetScrollPropPtr;
                                                                                        >  7256  // #endif
                                                                                        >  7257  
                                                                                        >  7258  extern(Windows) export int FlatSB_SetScrollPos(HWND, int code, int pos, BOOL fRe
                                                                                        >  7259  
                                                                                        >  7260  extern(Windows) export int FlatSB_SetScrollInfo(HWND, int code, LPSCROLLINFO, BO
                                                                                        >  7261  
                                                                                        >  7262  extern(Windows) export int FlatSB_SetScrollRange(HWND, int code, int min, int ma
                                                                                        >  7263  extern(Windows) export BOOL FlatSB_SetScrollProp(HWND, UINT index, INT_PTR newVa
                                                                                        >  7264  alias FlatSB_SetScrollProp FlatSB_SetScrollPropPtr;
                                                                                        >  7265  
                                                                                        >  7266  extern(Windows) export BOOL InitializeFlatSB(HWND);
                                                                                        >  7267  extern(Windows) export HRESULT UninitializeFlatSB(HWND);
                                                                                        >  7268  
                                                                                        >  7269  // #endif  //  NOFLATSBAPIS
                                                                                        >  7270  
                                                                                        >  7271  // #endif      // _WIN32_IE >= 0x0400
                                                                                        >  7272  
                                                                                        >  7273  // #endif /* _WIN32 */
                                                                                        >  7274  
                                                                                        >  7275  // #endif      // _WIN32_IE >= 0x0300
                                                                                        >  7276  
                                                                                        >  7277  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  7278  
                                                                                        >  7279  extern(Windows) alias LRESULT function(HWND hWnd, UINT uMsg, WPARAM wParam, LPAR
                                                                                        >  7280  
                                                                                        >  7281  extern(Windows) export BOOL SetWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclas
                                                                                        >  7282    DWORD_PTR dwRefData);
                                                                                        >  7283  extern(Windows) export BOOL GetWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclas
                                                                                        >  7284    DWORD_PTR *pdwRefData);
                                                                                        >  7285  extern(Windows) export BOOL RemoveWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubc
                                                                                        >  7286    UINT_PTR uIdSubclass);
                                                                                        >  7287  
                                                                                        >  7288  extern(Windows) export LRESULT DefSubclassProc(HWND hWnd, UINT uMsg, WPARAM wPar
                                                                                        >  7289  // #endif
                                                                                        >  7290  
                                                                                        >  7291  // #if (_WIN32_WINNT >= 0x501)
                                                                                        >  7292  
                                                                                        >  7293  extern(Windows) export int DrawShadowText(HDC hdc, LPCWSTR pszText, UINT cch, RE
                                                                                        >  7294    int ixOffset, int iyOffset);
                                                                                        >  7295  // #endif
                                                                                        >  7296  
                                                                                        >  7297  // #if !defined(RC_INVOKED) /* RC complains about long symbols in #ifs */
                                                                                        >  7298  // #if ISOLATION_AWARE_ENABLED
                                                                                        >  7299  
                                                                                        >  7300  // #if !defined(ISOLATION_AWARE_INLINE)
                                                                                        >  7301  // #if defined(__cplusplus)
                                                                                        >  7302  // #...
                                                                                        >  7303  // #else
                                                                                        >  7304  // #...
                                                                                        >  7305  // #endif
                                                                                        >  7306  // #endif
                                                                                        >  7307  
                                                                                        >  7308  // ...
                                                                                        >  7309  
                                                                                        >  7310  // ...
                                                                                        >  7311  // #if defined(__IStream_INTERFACE_DEFINED__)
                                                                                        >  7312  // ...
                                                                                        >  7313  // #if defined(__IStream_INTERFACE_DEFINED__) &&  (_WIN32_WINNT >= 0x0501)
                                                                                        >  7314  // ...
                                                                                        >  7315  // #endif /* defined(__IStream_INTERFACE_DEFINED__) &&  (_WIN32_WINNT >= 0x0501)
                                                                                        >  7316  // #endif /* defined(__IStream_INTERFACE_DEFINED__) */
                                                                                        >  7317  // ...
                                                                                        >  7318  // #if !defined(NOTRACKMOUSEEVENT)
                                                                                        >  7319  // ...
                                                                                        >  7320  // #endif /* !defined(NOTRACKMOUSEEVENT) */
                                                                                        >  7321  // ...
                                                                                        >  7322  // #if (_WIN32_IE >= 0x560)
                                                                                        >  7323  // ...
                                                                                        >  7324  // #endif /* (_WIN32_IE >= 0x560) */
                                                                                        >  7325  // ...
                                                                                        >  7326  
                                                                                        >  7327  // #if defined(UNICODE)
                                                                                        >  7328  
                                                                                        >  7329  // #...
                                                                                        >  7330  // #...
                                                                                        >  7331  // #...
                                                                                        >  7332  
                                                                                        >  7333  // #else /* UNICODE */
                                                                                        >  7334  
                                                                                        >  7335  // #...
                                                                                        >  7336  // #...
                                                                                        >  7337  // #...
                                                                                        >  7338  
                                                                                        >  7339  // #endif /* UNICODE */
                                                                                        >  7340  
                                                                                        >  7341  // ...
                                                                                        >  7342  
                                                                                        >  7343  // ...
                                                                                        >  7344  
                                                                                        >  7345  // ...
                                                                                        >  7346  
                                                                                        >  7347  // ...
                                                                                        >  7348  
                                                                                        >  7349  // ...
                                                                                        >  7350  
                                                                                        >  7351  // ...
                                                                                        >  7352  
                                                                                        >  7353  // ...
                                                                                        >  7354  
                                                                                        >  7355  // ...
                                                                                        >  7356  
                                                                                        >  7357  // ...
                                                                                        >  7358  
                                                                                        >  7359  // ...
                                                                                        >  7360  
                                                                                        >  7361  // ...
                                                                                        >  7362  
                                                                                        >  7363  // ...
                                                                                        >  7364  
                                                                                        >  7365  // ...
                                                                                        >  7366  
                                                                                        >  7367  // ...
                                                                                        >  7368  
                                                                                        >  7369  // ...
                                                                                        >  7370  
                                                                                        >  7371  // ...
                                                                                        >  7372  
                                                                                        >  7373  // ...
                                                                                        >  7374  
                                                                                        >  7375  // ...
                                                                                        >  7376  
                                                                                        >  7377  // ...
                                                                                        >  7378  
                                                                                        >  7379  // ...
                                                                                        >  7380  
                                                                                        >  7381  // ...
                                                                                        >  7382  
                                                                                        >  7383  // ...
                                                                                        >  7384  
                                                                                        >  7385  // ...
                                                                                        >  7386  
                                                                                        >  7387  // ...
                                                                                        >  7388  
                                                                                        >  7389  // ...
                                                                                        >  7390  
                                                                                        >  7391  // ...
                                                                                        >  7392  
                                                                                        >  7393  // ...
                                                                                        >  7394  
                                                                                        >  7395  // ...
                                                                                        >  7396  
                                                                                        >  7397  // ...
                                                                                        >  7398  
                                                                                        >  7399  // #if defined(__IStream_INTERFACE_DEFINED__)
                                                                                        >  7400  
                                                                                        >  7401  // ...
                                                                                        >  7402  
                                                                                        >  7403  // ...
                                                                                        >  7404  
                                                                                        >  7405  // #if defined(__IStream_INTERFACE_DEFINED__) &&  (_WIN32_WINNT >= 0x0501)
                                                                                        >  7406  
                                                                                        >  7407  // ...
                                                                                        >  7408  
                                                                                        >  7409  // ...
                                                                                        >  7410  
                                                                                        >  7411  // ...
                                                                                        >  7412  
                                                                                        >  7413  // ...
                                                                                        >  7414  
                                                                                        >  7415  // #endif /* defined(__IStream_INTERFACE_DEFINED__) &&  (_WIN32_WINNT >= 0x0501)
                                                                                        >  7416  // #endif /* defined(__IStream_INTERFACE_DEFINED__) */
                                                                                        >  7417  
                                                                                        >  7418  // ...
                                                                                        >  7419  
                                                                                        >  7420  // ...
                                                                                        >  7421  
                                                                                        >  7422  // ...
                                                                                        >  7423  
                                                                                        >  7424  // ...
                                                                                        >  7425  
                                                                                        >  7426  // ...
                                                                                        >  7427  
                                                                                        >  7428  // ...
                                                                                        >  7429  
                                                                                        >  7430  // ...
                                                                                        >  7431  
                                                                                        >  7432  // ...
                                                                                        >  7433  
                                                                                        >  7434  // ...
                                                                                        >  7435  
                                                                                        >  7436  // ...
                                                                                        >  7437  
                                                                                        >  7438  // ...
                                                                                        >  7439  
                                                                                        >  7440  // ...
                                                                                        >  7441  
                                                                                        >  7442  // ...
                                                                                        >  7443  
                                                                                        >  7444  // ...
                                                                                        >  7445  
                                                                                        >  7446  // ...
                                                                                        >  7447  
                                                                                        >  7448  // ...
                                                                                        >  7449  
                                                                                        >  7450  // ...
                                                                                        >  7451  
                                                                                        >  7452  // ...
                                                                                        >  7453  
                                                                                        >  7454  // ...
                                                                                        >  7455  
                                                                                        >  7456  // ...
                                                                                        >  7457  
                                                                                        >  7458  // #if !defined(NOTRACKMOUSEEVENT)
                                                                                        >  7459  
                                                                                        >  7460  // ...
                                                                                        >  7461  
                                                                                        >  7462  // #endif /* !defined(NOTRACKMOUSEEVENT) */
                                                                                        >  7463  
                                                                                        >  7464  // ...
                                                                                        >  7465  
                                                                                        >  7466  // ...
                                                                                        >  7467  
                                                                                        >  7468  // ...
                                                                                        >  7469  
                                                                                        >  7470  // ...
                                                                                        >  7471  
                                                                                        >  7472  // ...
                                                                                        >  7473  
                                                                                        >  7474  // ...
                                                                                        >  7475  
                                                                                        >  7476  // ...
                                                                                        >  7477  // #if defined(_WIN64)
                                                                                        >  7478  // ...
                                                                                        >  7479  // #else
                                                                                        >  7480  // ...
                                                                                        >  7481  // #endif
                                                                                        >  7482  // ...
                                                                                        >  7483  
                                                                                        >  7484  // ...
                                                                                        >  7485  
                                                                                        >  7486  // ...
                                                                                        >  7487  
                                                                                        >  7488  // ...
                                                                                        >  7489  
                                                                                        >  7490  // ...
                                                                                        >  7491  
                                                                                        >  7492  // ...
                                                                                        >  7493  
                                                                                        >  7494  // ...
                                                                                        >  7495  
                                                                                        >  7496  // ...
                                                                                        >  7497  
                                                                                        >  7498  // #if (_WIN32_IE >= 0x560)
                                                                                        >  7499  
                                                                                        >  7500  // ...
                                                                                        >  7501  
                                                                                        >  7502  // ...
                                                                                        >  7503  
                                                                                        >  7504  // ...
                                                                                        >  7505  
                                                                                        >  7506  // #endif /* (_WIN32_IE >= 0x560) */
                                                                                        >  7507  
                                                                                        >  7508  // ...
                                                                                        >  7509  
                                                                                        >  7510  // ...
                                                                                        >  7511  
                                                                                        >  7512  // ...
                                                                                        >  7513  
                                                                                        >  7514  // #...
                                                                                        >  7515  // #...
                                                                                        >  7516  // #...
                                                                                        >  7517  // #...
                                                                                        >  7518  // #...
                                                                                        >  7519  // #...
                                                                                        >  7520  // #...
                                                                                        >  7521  // #...
                                                                                        >  7522  // #...
                                                                                        >  7523  // #...
                                                                                        >  7524  // #...
                                                                                        >  7525  // #...
                                                                                        >  7526  // #...
                                                                                        >  7527  // #...
                                                                                        >  7528  // #if defined(FlatSB_GetScrollPropPtr)
                                                                                        >  7529  // #...
                                                                                        >  7530  // #endif
                                                                                        >  7531  // #...
                                                                                        >  7532  // #...
                                                                                        >  7533  // #...
                                                                                        >  7534  // #...
                                                                                        >  7535  // #...
                                                                                        >  7536  // #...
                                                                                        >  7537  // #...
                                                                                        >  7538  // #...
                                                                                        >  7539  // #...
                                                                                        >  7540  // #...
                                                                                        >  7541  // #...
                                                                                        >  7542  // #...
                                                                                        >  7543  // #...
                                                                                        >  7544  // #...
                                                                                        >  7545  // #...
                                                                                        >  7546  // #...
                                                                                        >  7547  // #...
                                                                                        >  7548  // #...
                                                                                        >  7549  // #...
                                                                                        >  7550  // #...
                                                                                        >  7551  // #...
                                                                                        >  7552  // #...
                                                                                        >  7553  // #...
                                                                                        >  7554  // #...
                                                                                        >  7555  // #...
                                                                                        >  7556  // #...
                                                                                        >  7557  // #...
                                                                                        >  7558  // #...
                                                                                        >  7559  // #...
                                                                                        >  7560  // #...
                                                                                        >  7561  // #...
                                                                                        >  7562  // #...
                                                                                        >  7563  // #...
                                                                                        >  7564  // #...
                                                                                        >  7565  // #...
                                                                                        >  7566  // #...
                                                                                        >  7567  // #...
                                                                                        >  7568  // #...
                                                                                        >  7569  // #...
                                                                                        >  7570  // #...
                                                                                        >  7571  // #...
                                                                                        >  7572  // #...
                                                                                        >  7573  // #...
                                                                                        >  7574  // #...
                                                                                        >  7575  // #...
                                                                                        >  7576  // #...
                                                                                        >  7577  // #...
                                                                                        >  7578  // #...
                                                                                        >  7579  // #...
                                                                                        >  7580  // #...
                                                                                        >  7581  // #...
                                                                                        >  7582  // #...
                                                                                        >  7583  // #...
                                                                                        >  7584  // #...
                                                                                        >  7585  // #...
                                                                                        >  7586  // #...
                                                                                        >  7587  // #...
                                                                                        >  7588  // #...
                                                                                        >  7589  
                                                                                        >  7590  // #endif /* ISOLATION_AWARE_ENABLED */
                                                                                        >  7591  // #endif /* RC */
                                                                                        >  7592  
                                                                                        >  7593  // #ifdef __cplusplus
                                                                                        >  7594  // }
                                                                                        >  7595  // #endif
                                                                                        >  7596  
                                                                                        >  7597  // #endif
                                                                                        >  7598  
                                                                                        >  7599  // #endif  // _INC_COMMCTRL
                                                                                        >  7600