• 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, .LZH,
           27  +                         // .LZS, .PAK, .RAR, .TAZ, .TBZ, .TGZ, .Z, .ZIP, .ZOO
           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.fname), false );
          204  +     if( outf is null )
          205  +      throw new BgaMelterError(ERROR_FILE_OPEN);
          206  +
          207  +     // 隗｣蜃榊�ｦ逅�
          208  +     bool bContinue = true;
          209  +     if( !is_compressed(hdr) )
          210  +      bContinue = NcDec( hdr.original_size, outf, ph );
          211  +     else if( hdr.method == "GZIP" )
          212  +      bContinue = GzDec( hdr.compressed_size, hdr.original_size, outf, ph );
          213  +     else if( hdr.method == "BZ2\0" )
          214  +      bContinue = BzDec( hdr.original_size, outf, ph );
          215  +
          216  +     // 髢峨§縺ｦ螻樊�ｧ險ｭ螳�
          217  +     outf.close();
          218  +     dosSetFTime( hdr.fname, hdr.date, hdr.time );
          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)+(dat[i+3]<<24);
          247  +   uint fnlen    = dat[i+24]+(dat[i+25]<<8)+dat[i+26]+(dat[i+27]<<8);
          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_name_len);
          271  +  if( hdr.fname.length < hdr.dir_name_len + hdr.file_name_len ) return false;
          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 optimization
          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 false;
          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<65536 ? csiz : 65536 );
          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 false;
          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 false;
          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?BUFSIZ:usiz )) )
          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) ) return false;
          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")(a);
          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))("BgaGetArcOriginalSize")(a);
          153  + }
          154  +
          155  + DWORD BgaGetArcCompressedSize( HARC a )
          156  + {
          157  +  return api!(typeof(&BgaGetArcCompressedSize))("BgaGetArcCompressedSize")(a);
          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")(a,b);
          183  +  if( r ) BgaSetOwnerWindowEx_impl(a,b);
          184  +  return r;
          185  + }
          186  +
          187  + BOOL BgaKillOwnerWindowEx( HWND a )
          188  + {
          189  +  BOOL r = api!(typeof(&BgaKillOwnerWindowEx))("BgaKillOwnerWindowEx")(a);
          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))("BgaSetEnumMembersProc")(a);
          198  + }
          199  +
          200  + BOOL BgaClearEnumMembersProc()
          201  + {
          202  +  return api!(typeof(&BgaClearEnumMembersProc))("BgaClearEnumMembersProc")();
          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"), wnd );
          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..length]
          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_len .. length] );
          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.isfile(hdr.fname) )
          337  +     // -n
          338  +     if( newfile_only )
          339  +     {
          340  +      if( newer_than(hdr.date,hdr.time,hdr.fname) )
          341  +       return BgaAnswer.SkipIt;
          342  +     }
          343  +     else
          344  +     {
          345  +      int r = MessageBox( dlg?dlg.hwnd:wnd,
          346  +       toStringz("Overwrite "~hdr.fname~" ?"),
          347  +       "QBga32.dll", MB_YESNOCANCEL );
          348  +      if( r == IDNO )     return BgaAnswer.SkipIt;
          349  +      if( r == IDCANCEL ) return BgaAnswer.Abort;
          350  +     }
          351  +    } catch {}
          352  +
          353  +   cur_hdr = hdr;
          354  +   if( !do_ownerwnd_proc( OP_FILE_BEGIN, &cur_hdr, 0, src_fname ) )
          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, src_fname ) )
          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.original_size*1000 );
          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_USERDATA);
           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*65535),0); }
          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 .. param.length] );
          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_READ | GENERIC_WRITE,
          143  +          FILE_SHARE_READ,NULL,
          144  +          OPEN_EXISTING,
          145  +          FILE_ATTRIBUTE_NORMAL,
          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_WRITE,
          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)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))
           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) LPFNPSPCALLBACKA;
          105  +extern(Windows) alias UINT function(HWND hwnd, UINT uMsg,  _PROPSHEETPAGEW *ppsp) LPFNPSPCALLBACKW;
          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, pszHeaderSubTitle)
          146  +// #define PROPSHEETPAGEW_V2_SIZE CCSIZEOF_STRUCT(PROPSHEETPAGEW, pszHeaderSubTitle)
          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 hInstance; union { LPCSTR pszTemplate; PROPSHEETPAGE_RESOURCE pResource; } DUMMYUNIONNAME; union { HICON hIcon; LPCSTR pszIcon; } DUMMYUNIONNAME2; LPCSTR pszTitle; DLGPROC pfnDlgProc; LPARAM lParam; LPFNPSPCALLBACKA pfnCallback; UINT *pcRefParent;
          155  +// #define PROPSHEETPAGEW_V1_FIELDS DWORD dwSize; DWORD dwFlags; HINSTANCE hInstance; union { LPCWSTR pszTemplate; PROPSHEETPAGE_RESOURCE pResource; } DUMMYUNIONNAME; union { HICON hIcon; LPCWSTR pszIcon; } DUMMYUNIONNAME2; LPCWSTR pszTitle; DLGPROC pfnDlgProc; LPARAM lParam; LPFNPSPCALLBACKW pfnCallback; UINT *pcRefParent;
          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, pfnCallback)
          431  +// #define PROPSHEETHEADERW_V1_SIZE CCSIZEOF_STRUCT(PROPSHEETHEADERW, pfnCallback)
          432  +
          433  +// #define PROPSHEETHEADERA_V2_SIZE CCSIZEOF_STRUCT(PROPSHEETHEADERA, DUMMYUNION5_MEMBER(hbmHeader))
          434  +// #define PROPSHEETHEADERW_V2_SIZE CCSIZEOF_STRUCT(PROPSHEETHEADERW, DUMMYUNION5_MEMBER(hbmHeader))
          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 constPropSheetPagePointer);
          554  +extern(Windows) export HPROPSHEETPAGE CreatePropertySheetPageW(LPCPROPSHEETPAGEW constPropSheetPagePointer);
          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) LPFNADDPROPSHEETPAGES;
          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, (WPARAM)index, (LPARAM)hpage)
          608  +
          609  +enum : uint { PSM_REMOVEPAGE = WM_USER + 102 }
          610  +// #define PropSheet_RemovePage(hDlg, index, hpage) SNDMSG(hDlg, PSM_REMOVEPAGE, index, (LPARAM)hpage)
          611  +
          612  +enum : uint { PSM_ADDPAGE = WM_USER + 103 }
          613  +// #define PropSheet_AddPage(hDlg, hpage) SNDMSG(hDlg, PSM_ADDPAGE, 0, (LPARAM)hpage)
          614  +
          615  +enum : uint { PSM_CHANGED = WM_USER + 104 }
          616  +// #define PropSheet_Changed(hDlg, hwnd) SNDMSG(hDlg, PSM_CHANGED, (WPARAM)hwnd, 0L)
          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, 0L)
          626  +
          627  +enum : uint { PSM_QUERYSIBLINGS = WM_USER + 108 }
          628  +// #define PropSheet_QuerySiblings(hDlg, wParam, lParam) SNDMSG(hDlg, PSM_QUERYSIBLINGS, wParam, lParam)
          629  +
          630  +enum : uint { PSM_UNCHANGED = WM_USER + 109 }
          631  +// #define PropSheet_UnChanged(hDlg, hwnd) SNDMSG(hDlg, PSM_UNCHANGED, (WPARAM)hwnd, 0L)
          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, wStyle, (LPARAM)(LPCTSTR)(lpszText))
          646  +
          647  +enum : uint { PSM_SETWIZBUTTONS = WM_USER + 112 }
          648  +// #define PropSheet_SetWizButtons(hDlg, dwFlags) PostMessage(hDlg, PSM_SETWIZBUTTONS, 0, (LPARAM)dwFlags)
          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_PRESSBUTTON, (WPARAM)iButton, 0)
          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, (LPARAM)id)
          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_SETFINISHTEXT, 0, (LPARAM)lpszText)
          680  +
          681  +enum : uint { PSM_GETTABCONTROL = WM_USER + 116 }
          682  +// #define PropSheet_GetTabControl(hDlg) (HWND)SNDMSG(hDlg, PSM_GETTABCONTROL, 0, 0)
          683  +
          684  +enum : uint { PSM_ISDIALOGMESSAGE = WM_USER + 117 }
          685  +// #define PropSheet_IsDialogMessage(hDlg, pMsg) (BOOL)SNDMSG(hDlg, PSM_ISDIALOGMESSAGE, 0, (LPARAM)pMsg)
          686  +
          687  +enum : uint { PSM_GETCURRENTPAGEHWND = WM_USER + 118 }
          688  +// #define PropSheet_GetCurrentPageHwnd(hDlg) (HWND)SNDMSG(hDlg, PSM_GETCURRENTPAGEHWND, 0, 0L)
          689  +
          690  +enum : uint { PSM_INSERTPAGE = WM_USER + 119 }
          691  +// #define PropSheet_InsertPage(hDlg, index, hpage) SNDMSG(hDlg, PSM_INSERTPAGE, (WPARAM)(index), (LPARAM)(hpage))
          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_SETHEADERTITLE, (WPARAM)(index), (LPARAM)(lpszText))
          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_SETHEADERSUBTITLE, (WPARAM)(index), (LPARAM)(lpszText))
          715  +
          716  +enum : uint { PSM_HWNDTOINDEX = WM_USER + 129 }
          717  +// #define PropSheet_HwndToIndex(hDlg, hwnd) (int)SNDMSG(hDlg, PSM_HWNDTOINDEX, (WPARAM)(hwnd), 0)
          718  +
          719  +enum : uint { PSM_INDEXTOHWND = WM_USER + 130 }
          720  +// #define PropSheet_IndexToHwnd(hDlg, i) (HWND)SNDMSG(hDlg, PSM_INDEXTOHWND, (WPARAM)(i), 0)
          721  +
          722  +enum : uint { PSM_PAGETOINDEX = WM_USER + 131 }
          723  +// #define PropSheet_PageToIndex(hDlg, hpage) (int)SNDMSG(hDlg, PSM_PAGETOINDEX, 0, (LPARAM)(hpage))
          724  +
          725  +enum : uint { PSM_INDEXTOPAGE = WM_USER + 132 }
          726  +// #define PropSheet_IndexToPage(hDlg, i) (HPROPSHEETPAGE)SNDMSG(hDlg, PSM_INDEXTOPAGE, (WPARAM)(i), 0)
          727  +
          728  +enum : uint { PSM_IDTOINDEX = WM_USER + 133 }
          729  +// #define PropSheet_IdToIndex(hDlg, id) (int)SNDMSG(hDlg, PSM_IDTOINDEX, 0, (LPARAM)(id))
          730  +
          731  +enum : uint { PSM_INDEXTOID = WM_USER + 134 }
          732  +// #define PropSheet_IndexToId(hDlg, i) SNDMSG(hDlg, PSM_INDEXTOID, (WPARAM)(i), 0)
          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, 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), (NMHDR *)(lParam))
         1014  +// #define FORWARD_WM_NOTIFY(hwnd, idFrom, pnmhdr, fn) (LRESULT)(fn)((hwnd), WM_NOTIFY, (WPARAM)(int)(idFrom), (LPARAM)(NMHDR *)(pnmhdr))
         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)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))
         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, dwRop)
         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, int cInitial, int cGrow);
         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 uNewCount);
         1296  +// #endif
         1297  +
         1298  +extern(Windows) export int ImageList_Add(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask);
         1299  +
         1300  +extern(Windows) export int ImageList_ReplaceIcon(HIMAGELIST himl, int i, HICON hicon);
         1301  +extern(Windows) export COLORREF ImageList_SetBkColor(HIMAGELIST himl, COLORREF clrBk);
         1302  +extern(Windows) export COLORREF ImageList_GetBkColor(HIMAGELIST himl);
         1303  +extern(Windows) export BOOL ImageList_SetOverlayImage(HIMAGELIST himl, int iImage, int iOverlay);
         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, int x, int y, UINT fStyle);
         1334  +
         1335  +// #ifdef _WIN32
         1336  +
         1337  +extern(Windows) export BOOL ImageList_Replace(HIMAGELIST himl, int i, HBITMAP hbmImage, HBITMAP hbmMask);
         1338  +
         1339  +extern(Windows) export int ImageList_AddMasked(HIMAGELIST himl, HBITMAP hbmImage, COLORREF crMask);
         1340  +extern(Windows) export BOOL ImageList_DrawEx(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, int dx, int dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle);
         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 flags);
         1346  +extern(Windows) export HIMAGELIST ImageList_LoadImageA(HINSTANCE hi, LPCSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags);
         1347  +extern(Windows) export HIMAGELIST ImageList_LoadImageW(HINSTANCE hi, LPCWSTR lpbmp, int cx, int cGrow, COLORREF crMask, UINT uType, UINT uFlags);
         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, HIMAGELIST himlSrc, int iSrc, UINT uFlags);
         1359  +// #endif
         1360  +
         1361  +extern(Windows) export BOOL ImageList_BeginDrag(HIMAGELIST himlTrack, int iTrack, int dxHotspot, int dyHotspot);
         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, int iDrag, int dxHotspot, int dyHotspot);
         1367  +
         1368  +extern(Windows) export BOOL ImageList_DragShowNolock(BOOL fShow);
         1369  +extern(Windows) export HIMAGELIST ImageList_GetDragImage(POINT *ppt,POINT *pptHotspot);
         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_LoadImage(hi, lpbmp, cx, cGrow, crMask, IMAGE_BITMAP, 0)
         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 *cy);
         1402  +extern(Windows) export BOOL ImageList_SetIconSize(HIMAGELIST himl, int cx, int cy);
         1403  +extern(Windows) export BOOL ImageList_GetImageInfo(HIMAGELIST himl, int i, IMAGEINFO *pImageInfo);
         1404  +extern(Windows) export HIMAGELIST ImageList_Merge(HIMAGELIST himl1, int i1, HIMAGELIST himl2, int i2, int dx, int dy);
         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, 0L)
         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_INSERTITEM, (WPARAM)(int)(i), (LPARAM)(const HD_ITEM *)(phdi))
         1592  +
         1593  +enum : uint { HDM_DELETEITEM = HDM_FIRST + 2 }
         1594  +// #define Header_DeleteItem(hwndHD, i) (BOOL)SNDMSG((hwndHD), HDM_DELETEITEM, (WPARAM)(int)(i), 0L)
         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, (WPARAM)(int)(i), (LPARAM)(HD_ITEM *)(phdi))
         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, (WPARAM)(int)(i), (LPARAM)(const HD_ITEM *)(phdi))
         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, (LPARAM)(HD_LAYOUT *)(playout))
         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_GETITEMRECT, (WPARAM)(iItem), (LPARAM)(lprc))
         1667  +
         1668  +enum : uint { HDM_SETIMAGELIST = HDM_FIRST + 8 }
         1669  +// #define Header_SetImageList(hwnd, himl) (HIMAGELIST)SNDMSG((hwnd), HDM_SETIMAGELIST, 0, (LPARAM)(himl))
         1670  +
         1671  +enum : uint { HDM_GETIMAGELIST = HDM_FIRST + 9 }
         1672  +// #define Header_GetImageList(hwnd) (HIMAGELIST)SNDMSG((hwnd), HDM_GETIMAGELIST, 0, 0)
         1673  +
         1674  +enum : uint { HDM_ORDERTOINDEX = HDM_FIRST + 15 }
         1675  +// #define Header_OrderToIndex(hwnd, i) (int)SNDMSG((hwnd), HDM_ORDERTOINDEX, (WPARAM)(i), 0)
         1676  +
         1677  +enum : uint { HDM_CREATEDRAGIMAGE = HDM_FIRST + 16 }
         1678  +// #define Header_CreateDragImage(hwnd, i) (HIMAGELIST)SNDMSG((hwnd), HDM_CREATEDRAGIMAGE, (WPARAM)(i), 0)
         1679  +
         1680  +enum : uint { HDM_GETORDERARRAY = HDM_FIRST + 17 }
         1681  +// #define Header_GetOrderArray(hwnd, iCount, lpi) (BOOL)SNDMSG((hwnd), HDM_GETORDERARRAY, (WPARAM)(iCount), (LPARAM)(lpi))
         1682  +
         1683  +enum : uint { HDM_SETORDERARRAY = HDM_FIRST + 18 }
         1684  +// #define Header_SetOrderArray(hwnd, iCount, lpi) (BOOL)SNDMSG((hwnd), HDM_SETORDERARRAY, (WPARAM)(iCount), (LPARAM)(lpi))
         1685  +
         1686  +enum : uint { HDM_SETHOTDIVIDER = HDM_FIRST + 19 }
         1687  +// #define Header_SetHotDivider(hwnd, fPos, dw) (int)SNDMSG((hwnd), HDM_SETHOTDIVIDER, (WPARAM)(fPos), (LPARAM)(dw))
         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_SETBITMAPMARGIN, (WPARAM)(iWidth), 0)
         1695  +
         1696  +enum : uint { HDM_GETBITMAPMARGIN = HDM_FIRST + 21 }
         1697  +// #define Header_GetBitmapMargin(hwnd) (int)SNDMSG((hwnd), HDM_GETBITMAPMARGIN, 0, 0)
         1698  +// #endif
         1699  +
         1700  +// #if (_WIN32_IE >= 0x0400)
         1701  +alias CCM_SETUNICODEFORMAT HDM_SETUNICODEFORMAT;
         1702  +// #define Header_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), HDM_SETUNICODEFORMAT, (WPARAM)(fUnicode), 0)
         1703  +
         1704  +alias CCM_GETUNICODEFORMAT HDM_GETUNICODEFORMAT;
         1705  +// #define Header_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), HDM_GETUNICODEFORMAT, 0, 0)
         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_SETFILTERCHANGETIMEOUT, 0, (LPARAM)(i))
         1711  +
         1712  +enum : uint { HDM_EDITFILTER = HDM_FIRST+23 }
         1713  +// #define Header_EditFilter(hwnd, i, fDiscardChanges) (int)SNDMSG((hwnd), HDM_EDITFILTER, (WPARAM)(i), MAKELPARAM(fDiscardChanges, 0))
         1714  +
         1715  +enum : uint { HDM_CLEARFILTER = HDM_FIRST+24 }
         1716  +// #define Header_ClearFilter(hwnd, i) (int)SNDMSG((hwnd), HDM_CLEARFILTER, (WPARAM)(i), 0)
         1717  +// #define Header_ClearAllFilters(hwnd) (int)SNDMSG((hwnd), HDM_CLEARFILTER, (WPARAM)-1, 0)
         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 nBitmaps,
         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 idBitmap,
         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, UINT uFlags);
         3277  +extern(Windows) export void DrawStatusTextW(HDC hDC, LPRECT lprc, LPCWSTR pszText, UINT uFlags);
         3278  +
         3279  +extern(Windows) export HWND CreateStatusWindowA(LONG style, LPCSTR lpszText, HWND hwndParent, UINT wID);
         3280  +extern(Windows) export HWND CreateStatusWindowW(LONG style, LPCWSTR lpszText, HWND hwndParent, UINT wID);
         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, HMENU hMainMenu, HINSTANCE hInst, HWND hwndStatus, UINT *lpwIDs);
         3373  +extern(Windows) export BOOL ShowHideMenuCtl(HWND hWnd, UINT_PTR uFlags, LPINT lpInfo);
         3374  +extern(Windows) export void GetEffectiveClientRect(HWND hWnd, LPRECT lprc, LPINT lpInfo);
         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 cx, int cy,
         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_SETUNICODEFORMAT, (WPARAM)(fUnicode), 0)
         3748  +
         3749  +alias CCM_GETUNICODEFORMAT LVM_GETUNICODEFORMAT;
         3750  +// #define ListView_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), LVM_GETUNICODEFORMAT, 0, 0)
         3751  +// #endif
         3752  +
         3753  +enum : uint { LVM_GETBKCOLOR = LVM_FIRST + 0 }
         3754  +// #define ListView_GetBkColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETBKCOLOR, 0, 0L)
         3755  +
         3756  +enum : uint { LVM_SETBKCOLOR = LVM_FIRST + 1 }
         3757  +// #define ListView_SetBkColor(hwnd, clrBk) (BOOL)SNDMSG((hwnd), LVM_SETBKCOLOR, 0, (LPARAM)(COLORREF)(clrBk))
         3758  +
         3759  +enum : uint { LVM_GETIMAGELIST = LVM_FIRST + 2 }
         3760  +// #define ListView_GetImageList(hwnd, iImageList) (HIMAGELIST)SNDMSG((hwnd), LVM_GETIMAGELIST, (WPARAM)(INT)(iImageList), 0L)
         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((hwnd), LVM_SETIMAGELIST, (WPARAM)(iImageList), (LPARAM)(HIMAGELIST)(himl))
         3768  +
         3769  +enum : uint { LVM_GETITEMCOUNT = LVM_FIRST + 4 }
         3770  +// #define ListView_GetItemCount(hwnd) (int)SNDMSG((hwnd), LVM_GETITEMCOUNT, 0, 0L)
         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, (LPARAM)(LV_ITEM *)(pitem))
         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, (LPARAM)(const LV_ITEM *)(pitem))
         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, 0, (LPARAM)(const LV_ITEM *)(pitem))
         3917  +
         3918  +enum : uint { LVM_DELETEITEM = LVM_FIRST + 8 }
         3919  +// #define ListView_DeleteItem(hwnd, i) (BOOL)SNDMSG((hwnd), LVM_DELETEITEM, (WPARAM)(int)(i), 0L)
         3920  +
         3921  +enum : uint { LVM_DELETEALLITEMS = LVM_FIRST + 9 }
         3922  +// #define ListView_DeleteAllItems(hwnd) (BOOL)SNDMSG((hwnd), LVM_DELETEALLITEMS, 0, 0L)
         3923  +
         3924  +enum : uint { LVM_GETCALLBACKMASK = LVM_FIRST + 10 }
         3925  +// #define ListView_GetCallbackMask(hwnd) (BOOL)SNDMSG((hwnd), LVM_GETCALLBACKMASK, 0, 0)
         3926  +
         3927  +enum : uint { LVM_SETCALLBACKMASK = LVM_FIRST + 11 }
         3928  +// #define ListView_SetCallbackMask(hwnd, mask) (BOOL)SNDMSG((hwnd), LVM_SETCALLBACKMASK, (WPARAM)(UINT)(mask), 0)
         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_GETNEXTITEM, (WPARAM)(int)(i), MAKELPARAM((flags), 0))
         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_FINDITEM, (WPARAM)(int)(iStart), (LPARAM)(const LV_FINDINFO *)(plvfi))
         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_GETITEMRECT, (WPARAM)(int)(i), ((prc) ? (((RECT *)(prc))->left = (code),(LPARAM)(RECT *)(prc)) : (LPARAM)(RECT *)NULL))
         4005  +
         4006  +enum : uint { LVM_SETITEMPOSITION = LVM_FIRST + 15 }
         4007  +// #define ListView_SetItemPosition(hwndLV, i, x, y) (BOOL)SNDMSG((hwndLV), LVM_SETITEMPOSITION, (WPARAM)(int)(i), MAKELPARAM((x), (y)))
         4008  +
         4009  +enum : uint { LVM_GETITEMPOSITION = LVM_FIRST + 16 }
         4010  +// #define ListView_GetItemPosition(hwndLV, i, ppt) (BOOL)SNDMSG((hwndLV), LVM_GETITEMPOSITION, (WPARAM)(int)(i), (LPARAM)(POINT *)(ppt))
         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_GETSTRINGWIDTH, 0, (LPARAM)(LPCTSTR)(psz))
         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_ONITEMSTATEICON }
         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, (LPARAM)(LV_HITTESTINFO *)(pinfo))
         4055  +
         4056  +enum : uint { LVM_ENSUREVISIBLE = LVM_FIRST + 19 }
         4057  +// #define ListView_EnsureVisible(hwndLV, i, fPartialOK) (BOOL)SNDMSG((hwndLV), LVM_ENSUREVISIBLE, (WPARAM)(int)(i), MAKELPARAM((fPartialOK), 0))
         4058  +
         4059  +enum : uint { LVM_SCROLL = LVM_FIRST + 20 }
         4060  +// #define ListView_Scroll(hwndLV, dx, dy) (BOOL)SNDMSG((hwndLV), LVM_SCROLL, (WPARAM)(int)(dx), (LPARAM)(int)(dy))
         4061  +
         4062  +enum : uint { LVM_REDRAWITEMS = LVM_FIRST + 21 }
         4063  +// #define ListView_RedrawItems(hwndLV, iFirst, iLast) (BOOL)SNDMSG((hwndLV), LVM_REDRAWITEMS, (WPARAM)(int)(iFirst), (LPARAM)(int)(iLast))
         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, (WPARAM)(UINT)(code), 0L)
         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, (WPARAM)(int)(i), 0L)
         4082  +
         4083  +enum : uint { LVM_GETEDITCONTROL = LVM_FIRST + 24 }
         4084  +// #define ListView_GetEditControl(hwndLV) (HWND)SNDMSG((hwndLV), LVM_GETEDITCONTROL, 0, 0L)
         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_GETCOLUMN, (WPARAM)(int)(iCol), (LPARAM)(LV_COLUMN *)(pcol))
         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_SETCOLUMN, (WPARAM)(int)(iCol), (LPARAM)(const LV_COLUMN *)(pcol))
         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_INSERTCOLUMN, (WPARAM)(int)(iCol), (LPARAM)(const LV_COLUMN *)(pcol))
         4190  +
         4191  +enum : uint { LVM_DELETECOLUMN = LVM_FIRST + 28 }
         4192  +// #define ListView_DeleteColumn(hwnd, iCol) (BOOL)SNDMSG((hwnd), LVM_DELETECOLUMN, (WPARAM)(int)(iCol), 0)
         4193  +
         4194  +enum : uint { LVM_GETCOLUMNWIDTH = LVM_FIRST + 29 }
         4195  +// #define ListView_GetColumnWidth(hwnd, iCol) (int)SNDMSG((hwnd), LVM_GETCOLUMNWIDTH, (WPARAM)(int)(iCol), 0)
         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_SETCOLUMNWIDTH, (WPARAM)(int)(iCol), MAKELPARAM((cx), 0))
         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((hwnd), LVM_CREATEDRAGIMAGE, (WPARAM)(int)(i), (LPARAM)(LPPOINT)(lpptUpLeft))
         4210  +
         4211  +enum : uint { LVM_GETVIEWRECT = LVM_FIRST + 34 }
         4212  +// #define ListView_GetViewRect(hwnd, prc) (BOOL)SNDMSG((hwnd), LVM_GETVIEWRECT, 0, (LPARAM)(RECT *)(prc))
         4213  +
         4214  +enum : uint { LVM_GETTEXTCOLOR = LVM_FIRST + 35 }
         4215  +// #define ListView_GetTextColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETTEXTCOLOR, 0, 0L)
         4216  +
         4217  +enum : uint { LVM_SETTEXTCOLOR = LVM_FIRST + 36 }
         4218  +// #define ListView_SetTextColor(hwnd, clrText) (BOOL)SNDMSG((hwnd), LVM_SETTEXTCOLOR, 0, (LPARAM)(COLORREF)(clrText))
         4219  +
         4220  +enum : uint { LVM_GETTEXTBKCOLOR = LVM_FIRST + 37 }
         4221  +// #define ListView_GetTextBkColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETTEXTBKCOLOR, 0, 0L)
         4222  +
         4223  +enum : uint { LVM_SETTEXTBKCOLOR = LVM_FIRST + 38 }
         4224  +// #define ListView_SetTextBkColor(hwnd, clrTextBk) (BOOL)SNDMSG((hwnd), LVM_SETTEXTBKCOLOR, 0, (LPARAM)(COLORREF)(clrTextBk))
         4225  +
         4226  +enum : uint { LVM_GETTOPINDEX = LVM_FIRST + 39 }
         4227  +// #define ListView_GetTopIndex(hwndLV) (int)SNDMSG((hwndLV), LVM_GETTOPINDEX, 0, 0)
         4228  +
         4229  +enum : uint { LVM_GETCOUNTPERPAGE = LVM_FIRST + 40 }
         4230  +// #define ListView_GetCountPerPage(hwndLV) (int)SNDMSG((hwndLV), LVM_GETCOUNTPERPAGE, 0, 0)
         4231  +
         4232  +enum : uint { LVM_GETORIGIN = LVM_FIRST + 41 }
         4233  +// #define ListView_GetOrigin(hwndLV, ppt) (BOOL)SNDMSG((hwndLV), LVM_GETORIGIN, (WPARAM)0, (LPARAM)(POINT *)(ppt))
         4234  +
         4235  +enum : uint { LVM_UPDATE = LVM_FIRST + 42 }
         4236  +// #define ListView_Update(hwndLV, i) (BOOL)SNDMSG((hwndLV), LVM_UPDATE, (WPARAM)(i), 0L)
         4237  +
         4238  +enum : uint { LVM_SETITEMSTATE = LVM_FIRST + 43 }
         4239  +// #define ListView_SetItemState(hwndLV, i, data, mask) { LV_ITEM _ms_lvi; _ms_lvi.stateMask = mask; _ms_lvi.state = data; SNDMSG((hwndLV), LVM_SETITEMSTATE, (WPARAM)(i), (LPARAM)(LV_ITEM *)&_ms_lvi); }
         4240  +
         4241  +// #if (_WIN32_IE >= 0x0300)
         4242  +// #define ListView_SetCheckState(hwndLV, i, fCheck) ListView_SetItemState(hwndLV, i, INDEXTOSTATEIMAGEMASK((fCheck)?2:1), LVIS_STATEIMAGEMASK)
         4243  +// #endif
         4244  +
         4245  +enum : uint { LVM_GETITEMSTATE = LVM_FIRST + 44 }
         4246  +// #define ListView_GetItemState(hwndLV, i, mask) (UINT)SNDMSG((hwndLV), LVM_GETITEMSTATE, (WPARAM)(i), (LPARAM)(mask))
         4247  +
         4248  +// #if (_WIN32_IE >= 0x0300)
         4249  +// #define ListView_GetCheckState(hwndLV, i) ((((UINT)(SNDMSG((hwndLV), LVM_GETITEMSTATE, (WPARAM)(i), LVIS_STATEIMAGEMASK))) >> 12) -1)
         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_) { LV_ITEM _ms_lvi; _ms_lvi.iSubItem = iSubItem_; _ms_lvi.cchTextMax = cchTextMax_; _ms_lvi.pszText = pszText_; SNDMSG((hwndLV), LVM_GETITEMTEXT, (WPARAM)(i), (LPARAM)(LV_ITEM *)&_ms_lvi); }
         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_lvi; _ms_lvi.iSubItem = iSubItem_; _ms_lvi.pszText = pszText_; SNDMSG((hwndLV), LVM_SETITEMTEXT, (WPARAM)(i), (LPARAM)(LV_ITEM *)&_ms_lvi); }
         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_SETITEMCOUNT, (WPARAM)(cItems), 0)
         4282  +
         4283  +// #if (_WIN32_IE >= 0x0300)
         4284  +// #define ListView_SetItemCountEx(hwndLV, cItems, dwFlags) SNDMSG((hwndLV), LVM_SETITEMCOUNT, (WPARAM)(cItems), (LPARAM)(dwFlags))
         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), LVM_SORTITEMS, (WPARAM)(LPARAM)(_lPrm), (LPARAM)(PFNLVCOMPARE)(_pfnCompare))
         4291  +
         4292  +enum : uint { LVM_SETITEMPOSITION32 = LVM_FIRST + 49 }
         4293  +// #define ListView_SetItemPosition32(hwndLV, i, x0, y0) { POINT ptNewPos; ptNewPos.x = x0; ptNewPos.y = y0; SNDMSG((hwndLV), LVM_SETITEMPOSITION32, (WPARAM)(int)(i), (LPARAM)&ptNewPos); }
         4294  +
         4295  +enum : uint { LVM_GETSELECTEDCOUNT = LVM_FIRST + 50 }
         4296  +// #define ListView_GetSelectedCount(hwndLV) (UINT)SNDMSG((hwndLV), LVM_GETSELECTEDCOUNT, 0, 0L)
         4297  +
         4298  +enum : uint { LVM_GETITEMSPACING = LVM_FIRST + 51 }
         4299  +// #define ListView_GetItemSpacing(hwndLV, fSmall) (DWORD)SNDMSG((hwndLV), LVM_GETITEMSPACING, fSmall, 0L)
         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_GETISEARCHSTRING, 0, (LPARAM)(LPTSTR)(lpsz))
         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_SETICONSPACING, 0, MAKELONG(cx,cy))
         4316  +
         4317  +enum : uint { LVM_SETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 54 }
         4318  +// #define ListView_SetExtendedListViewStyle(hwndLV, dw) (DWORD)SNDMSG((hwndLV), LVM_SETEXTENDEDLISTVIEWSTYLE, 0, dw)
         4319  +// #if (_WIN32_IE >= 0x0400)
         4320  +// #define ListView_SetExtendedListViewStyleEx(hwndLV, dwMask, dw) (DWORD)SNDMSG((hwndLV), LVM_SETEXTENDEDLISTVIEWSTYLE, dwMask, dw)
         4321  +// #endif
         4322  +
         4323  +enum : uint { LVM_GETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 55 }
         4324  +// #define ListView_GetExtendedListViewStyle(hwndLV) (DWORD)SNDMSG((hwndLV), LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0)
         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)SNDMSG((hwnd), LVM_GETSUBITEMRECT, (WPARAM)(int)(iItem), ((prc) ? ((((LPRECT)(prc))->top = iSubItem), (((LPRECT)(prc))->left = code), (LPARAM)(prc)) : (LPARAM)(LPRECT)NULL))
         4356  +
         4357  +enum : uint { LVM_SUBITEMHITTEST = LVM_FIRST + 57 }
         4358  +// #define ListView_SubItemHitTest(hwnd, plvhti) (int)SNDMSG((hwnd), LVM_SUBITEMHITTEST, 0, (LPARAM)(LPLVHITTESTINFO)(plvhti))
         4359  +
         4360  +enum : uint { LVM_SETCOLUMNORDERARRAY = LVM_FIRST + 58 }
         4361  +// #define ListView_SetColumnOrderArray(hwnd, iCount, pi) (BOOL)SNDMSG((hwnd), LVM_SETCOLUMNORDERARRAY, (WPARAM)(iCount), (LPARAM)(LPINT)(pi))
         4362  +
         4363  +enum : uint { LVM_GETCOLUMNORDERARRAY = LVM_FIRST + 59 }
         4364  +// #define ListView_GetColumnOrderArray(hwnd, iCount, pi) (BOOL)SNDMSG((hwnd), LVM_GETCOLUMNORDERARRAY, (WPARAM)(iCount), (LPARAM)(LPINT)(pi))
         4365  +
         4366  +enum : uint { LVM_SETHOTITEM = LVM_FIRST + 60 }
         4367  +// #define ListView_SetHotItem(hwnd, i) (int)SNDMSG((hwnd), LVM_SETHOTITEM, (WPARAM)(i), 0)
         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_SETHOTCURSOR, 0, (LPARAM)(hcur))
         4374  +
         4375  +enum : uint { LVM_GETHOTCURSOR = LVM_FIRST + 63 }
         4376  +// #define ListView_GetHotCursor(hwnd) (HCURSOR)SNDMSG((hwnd), LVM_GETHOTCURSOR, 0, 0)
         4377  +
         4378  +enum : uint { LVM_APPROXIMATEVIEWRECT = LVM_FIRST + 64 }
         4379  +// #define ListView_ApproximateViewRect(hwnd, iWidth, iHeight, iCount) (DWORD)SNDMSG((hwnd), LVM_APPROXIMATEVIEWRECT, iCount, MAKELPARAM(iWidth, iHeight))
         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_SETWORKAREAS, (WPARAM)(int)(nWorkAreas), (LPARAM)(RECT *)(prc))
         4387  +
         4388  +enum : uint { LVM_GETWORKAREAS = LVM_FIRST + 70 }
         4389  +// #define ListView_GetWorkAreas(hwnd, nWorkAreas, prc) (BOOL)SNDMSG((hwnd), LVM_GETWORKAREAS, (WPARAM)(int)(nWorkAreas), (LPARAM)(RECT *)(prc))
         4390  +
         4391  +enum : uint { LVM_GETNUMBEROFWORKAREAS = LVM_FIRST + 73 }
         4392  +// #define ListView_GetNumberOfWorkAreas(hwnd, pnWorkAreas) (BOOL)SNDMSG((hwnd), LVM_GETNUMBEROFWORKAREAS, 0, (LPARAM)(UINT *)(pnWorkAreas))
         4393  +
         4394  +enum : uint { LVM_GETSELECTIONMARK = LVM_FIRST + 66 }
         4395  +// #define ListView_GetSelectionMark(hwnd) (int)SNDMSG((hwnd), LVM_GETSELECTIONMARK, 0, 0)
         4396  +
         4397  +enum : uint { LVM_SETSELECTIONMARK = LVM_FIRST + 67 }
         4398  +// #define ListView_SetSelectionMark(hwnd, i) (int)SNDMSG((hwnd), LVM_SETSELECTIONMARK, 0, (LPARAM)(i))
         4399  +
         4400  +enum : uint { LVM_SETHOVERTIME = LVM_FIRST + 71 }
         4401  +// #define ListView_SetHoverTime(hwndLV, dwHoverTimeMs) (DWORD)SNDMSG((hwndLV), LVM_SETHOVERTIME, 0, (LPARAM)(dwHoverTimeMs))
         4402  +
         4403  +enum : uint { LVM_GETHOVERTIME = LVM_FIRST + 72 }
         4404  +// #define ListView_GetHoverTime(hwndLV) (DWORD)SNDMSG((hwndLV), LVM_GETHOVERTIME, 0, 0)
         4405  +
         4406  +enum : uint { LVM_SETTOOLTIPS = LVM_FIRST + 74 }
         4407  +// #define ListView_SetToolTips(hwndLV, hwndNewHwnd) (HWND)SNDMSG((hwndLV), LVM_SETTOOLTIPS, (WPARAM)(hwndNewHwnd), 0)
         4408  +
         4409  +enum : uint { LVM_GETTOOLTIPS = LVM_FIRST + 78 }
         4410  +// #define ListView_GetToolTips(hwndLV) (HWND)SNDMSG((hwndLV), LVM_GETTOOLTIPS, 0, 0)
         4411  +
         4412  +enum : uint { LVM_SORTITEMSEX = LVM_FIRST + 81 }
         4413  +// #define ListView_SortItemsEx(hwndLV, _pfnCompare, _lPrm) (BOOL)SNDMSG((hwndLV), LVM_SORTITEMSEX, (WPARAM)(LPARAM)(_lPrm), (LPARAM)(PFNLVCOMPARE)(_pfnCompare))
         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_SETSELECTEDCOLUMN, (WPARAM)iCol, 0)
         4457  +
         4458  +enum : uint { LVM_SETTILEWIDTH = LVM_FIRST + 141 }
         4459  +// #define ListView_SetTileWidth(hwnd, cpWidth) SNDMSG((hwnd), LVM_SETTILEWIDTH, (WPARAM)cpWidth, 0)
         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, (WPARAM)(DWORD)iView, 0)
         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_INSERTGROUP, (WPARAM)index, (LPARAM)pgrp)
         4509  +
         4510  +enum : uint { LVM_SETGROUPINFO = LVM_FIRST + 147 }
         4511  +// #define ListView_SetGroupInfo(hwnd, iGroupId, pgrp) SNDMSG((hwnd), LVM_SETGROUPINFO, (WPARAM)iGroupId, (LPARAM)pgrp)
         4512  +
         4513  +enum : uint { LVM_GETGROUPINFO = LVM_FIRST + 149 }
         4514  +// #define ListView_GetGroupInfo(hwnd, iGroupId, pgrp) SNDMSG((hwnd), LVM_GETGROUPINFO, (WPARAM)iGroupId, (LPARAM)pgrp)
         4515  +
         4516  +enum : uint { LVM_REMOVEGROUP = LVM_FIRST + 150 }
         4517  +// #define ListView_RemoveGroup(hwnd, iGroupId) SNDMSG((hwnd), LVM_REMOVEGROUP, (WPARAM)iGroupId, 0)
         4518  +
         4519  +enum : uint { LVM_MOVEGROUP = LVM_FIRST + 151 }
         4520  +// #define ListView_MoveGroup(hwnd, iGroupId, toIndex) SNDMSG((hwnd), LVM_MOVEGROUP, (WPARAM)iGroupId, (LPARAM)toIndex)
         4521  +
         4522  +enum : uint { LVM_MOVEITEMTOGROUP = LVM_FIRST + 154 }
         4523  +// #define ListView_MoveItemToGroup(hwnd, idItemFrom, idGroupTo) SNDMSG((hwnd), LVM_MOVEITEMTOGROUP, (WPARAM)idItemFrom, (LPARAM)idGroupTo)
         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_SETGROUPMETRICS, 0, (LPARAM)pGroupMetrics)
         4549  +
         4550  +enum : uint { LVM_GETGROUPMETRICS = LVM_FIRST + 156 }
         4551  +// #define ListView_GetGroupMetrics(hwnd, pGroupMetrics) SNDMSG((hwnd), LVM_GETGROUPMETRICS, 0, (LPARAM)pGroupMetrics)
         4552  +
         4553  +enum : uint { LVM_ENABLEGROUPVIEW = LVM_FIRST + 157 }
         4554  +// #define ListView_EnableGroupView(hwnd, fEnable) SNDMSG((hwnd), LVM_ENABLEGROUPVIEW, (WPARAM)fEnable, 0)
         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_SORTGROUPS, (WPARAM)_pfnGroupCompate, (LPARAM)_plv)
         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_INSERTGROUPSORTED, (WPARAM)structInsert, 0)
         4571  +
         4572  +enum : uint { LVM_REMOVEALLGROUPS = LVM_FIRST + 160 }
         4573  +// #define ListView_RemoveAllGroups(hwnd) SNDMSG((hwnd), LVM_REMOVEALLGROUPS, 0, 0)
         4574  +
         4575  +enum : uint { LVM_HASGROUP = LVM_FIRST + 161 }
         4576  +// #define ListView_HasGroup(hwnd, dwGroupId) SNDMSG((hwnd), LVM_HASGROUP, dwGroupId, 0)
         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_SETTILEVIEWINFO, 0, (LPARAM)ptvi)
         4609  +
         4610  +enum : uint { LVM_GETTILEVIEWINFO = LVM_FIRST + 163 }
         4611  +// #define ListView_GetTileViewInfo(hwnd, ptvi) SNDMSG((hwnd), LVM_GETTILEVIEWINFO, 0, (LPARAM)ptvi)
         4612  +
         4613  +enum : uint { LVM_SETTILEINFO = LVM_FIRST + 164 }
         4614  +// #define ListView_SetTileInfo(hwnd, pti) SNDMSG((hwnd), LVM_SETTILEINFO, 0, (LPARAM)pti)
         4615  +
         4616  +enum : uint { LVM_GETTILEINFO = LVM_FIRST + 165 }
         4617  +// #define ListView_GetTileInfo(hwnd, pti) SNDMSG((hwnd), LVM_GETTILEINFO, 0, (LPARAM)pti)
         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_SETINSERTMARK, (WPARAM) 0, (LPARAM) (lvim))
         4632  +
         4633  +enum : uint { LVM_GETINSERTMARK = LVM_FIRST + 167 }
         4634  +// #define ListView_GetInsertMark(hwnd, lvim) (BOOL)SNDMSG((hwnd), LVM_GETINSERTMARK, (WPARAM) 0, (LPARAM) (lvim))
         4635  +
         4636  +enum : uint { LVM_INSERTMARKHITTEST = LVM_FIRST + 168 }
         4637  +// #define ListView_InsertMarkHitTest(hwnd, point, lvim) (int)SNDMSG((hwnd), LVM_INSERTMARKHITTEST, (WPARAM)(LPPOINT)(point), (LPARAM)(LPLVINSERTMARK)(lvim))
         4638  +
         4639  +enum : uint { LVM_GETINSERTMARKRECT = LVM_FIRST + 169 }
         4640  +// #define ListView_GetInsertMarkRect(hwnd, rc) (int)SNDMSG((hwnd), LVM_GETINSERTMARKRECT, (WPARAM)0, (LPARAM)(LPRECT)(rc))
         4641  +
         4642  +enum : uint { LVM_SETINSERTMARKCOLOR = LVM_FIRST + 170 }
         4643  +// #define ListView_SetInsertMarkColor(hwnd, color) (COLORREF)SNDMSG((hwnd), LVM_SETINSERTMARKCOLOR, (WPARAM)0, (LPARAM)(COLORREF)(color))
         4644  +
         4645  +enum : uint { LVM_GETINSERTMARKCOLOR = LVM_FIRST + 171 }
         4646  +// #define ListView_GetInsertMarkColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETINSERTMARKCOLOR, (WPARAM)0, (LPARAM)0)
         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_SETINFOTIP, (WPARAM)0, (LPARAM)plvInfoTip)
         4661  +
         4662  +enum : uint { LVM_GETSELECTEDCOLUMN = LVM_FIRST + 174 }
         4663  +// #define ListView_GetSelectedColumn(hwnd) (UINT)SNDMSG((hwnd), LVM_GETSELECTEDCOLUMN, 0, 0)
         4664  +
         4665  +enum : uint { LVM_ISGROUPVIEWENABLED = LVM_FIRST + 175 }
         4666  +// #define ListView_IsGroupViewEnabled(hwnd) (BOOL)SNDMSG((hwnd), LVM_ISGROUPVIEWENABLED, 0, 0)
         4667  +
         4668  +enum : uint { LVM_GETOUTLINECOLOR = LVM_FIRST + 176 }
         4669  +// #define ListView_GetOutlineColor(hwnd) (COLORREF)SNDMSG((hwnd), LVM_GETOUTLINECOLOR, 0, 0)
         4670  +
         4671  +enum : uint { LVM_SETOUTLINECOLOR = LVM_FIRST + 177 }
         4672  +// #define ListView_SetOutlineColor(hwnd, color) (COLORREF)SNDMSG((hwnd), LVM_SETOUTLINECOLOR, (WPARAM)0, (LPARAM)(COLORREF)(color))
         4673  +
         4674  +enum : uint { LVM_CANCELEDITLABEL = LVM_FIRST + 179 }
         4675  +// #define ListView_CancelEditLabel(hwnd) (VOID)SNDMSG((hwnd), LVM_CANCELEDITLABEL, (WPARAM)0, (LPARAM)0)
         4676  +
         4677  +enum : uint { LVM_MAPINDEXTOID = LVM_FIRST + 180 }
         4678  +// #define ListView_MapIndexToID(hwnd, index) (UINT)SNDMSG((hwnd), LVM_MAPINDEXTOID, (WPARAM)index, (LPARAM)0)
         4679  +
         4680  +enum : uint { LVM_MAPIDTOINDEX = LVM_FIRST + 181 }
         4681  +// #define ListView_MapIDToIndex(hwnd, id) (UINT)SNDMSG((hwnd), LVM_MAPIDTOINDEX, (WPARAM)id, (LPARAM)0)
         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, 0, (LPARAM)(plvbki))
         4698  +
         4699  +// #define ListView_GetBkImage(hwnd, plvbki) (BOOL)SNDMSG((hwnd), LVM_GETBKIMAGE, 0, (LPARAM)(plvbki))
         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_INSERTITEM, 0, (LPARAM)(LPTV_INSERTSTRUCT)(lpis))
         5252  +
         5253  +enum : uint { TVM_DELETEITEM = TV_FIRST + 1 }
         5254  +// #define TreeView_DeleteItem(hwnd, hitem) (BOOL)SNDMSG((hwnd), TVM_DELETEITEM, 0, (LPARAM)(HTREEITEM)(hitem))
         5255  +
         5256  +// #define TreeView_DeleteAllItems(hwnd) (BOOL)SNDMSG((hwnd), TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT)
         5257  +
         5258  +enum : uint { TVM_EXPAND = TV_FIRST + 2 }
         5259  +// #define TreeView_Expand(hwnd, hitem, code) (BOOL)SNDMSG((hwnd), TVM_EXPAND, (WPARAM)(code), (LPARAM)(HTREEITEM)(hitem))
         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 = (hitem), (BOOL)SNDMSG((hwnd), TVM_GETITEMRECT, (WPARAM)(code), (LPARAM)(RECT *)(prc)))
         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, (WPARAM)(indent), 0)
         5280  +
         5281  +enum : uint { TVM_GETIMAGELIST = TV_FIRST + 8 }
         5282  +// #define TreeView_GetImageList(hwnd, iImage) (HIMAGELIST)SNDMSG((hwnd), TVM_GETIMAGELIST, iImage, 0)
         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), TVM_SETIMAGELIST, iImage, (LPARAM)(HIMAGELIST)(himl))
         5289  +
         5290  +enum : uint { TVM_GETNEXTITEM = TV_FIRST + 10 }
         5291  +// #define TreeView_GetNextItem(hwnd, hitem, code) (HTREEITEM)SNDMSG((hwnd), TVM_GETNEXTITEM, (WPARAM)(code), (LPARAM)(HTREEITEM)(hitem))
         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_CHILD)
         5312  +// #define TreeView_GetNextSibling(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem, TVGN_NEXT)
         5313  +// #define TreeView_GetPrevSibling(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem, TVGN_PREVIOUS)
         5314  +// #define TreeView_GetParent(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem, TVGN_PARENT)
         5315  +// #define TreeView_GetFirstVisible(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_FIRSTVISIBLE)
         5316  +// #define TreeView_GetNextVisible(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem, TVGN_NEXTVISIBLE)
         5317  +// #define TreeView_GetPrevVisible(hwnd, hitem) TreeView_GetNextItem(hwnd, hitem, TVGN_PREVIOUSVISIBLE)
         5318  +// #define TreeView_GetSelection(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_CARET)
         5319  +// #define TreeView_GetDropHilight(hwnd) TreeView_GetNextItem(hwnd, NULL, TVGN_DROPHILITE)
         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_LASTVISIBLE)
         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_SELECTITEM, (WPARAM)(code), (LPARAM)(HTREEITEM)(hitem))
         5327  +
         5328  +// #define TreeView_SelectItem(hwnd, hitem) TreeView_Select(hwnd, hitem, TVGN_CARET)
         5329  +// #define TreeView_SelectDropTarget(hwnd, hitem) TreeView_Select(hwnd, hitem, TVGN_DROPHILITE)
         5330  +// #define TreeView_SelectSetFirstVisible(hwnd, hitem) TreeView_Select(hwnd, hitem, TVGN_FIRSTVISIBLE)
         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, (LPARAM)(TV_ITEM *)(pitem))
         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, (LPARAM)(const TV_ITEM *)(pitem))
         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, (LPARAM)(HTREEITEM)(hitem))
         5363  +
         5364  +enum : uint { TVM_GETEDITCONTROL = TV_FIRST + 15 }
         5365  +// #define TreeView_GetEditControl(hwnd) (HWND)SNDMSG((hwnd), TVM_GETEDITCONTROL, 0, 0)
         5366  +
         5367  +enum : uint { TVM_GETVISIBLECOUNT = TV_FIRST + 16 }
         5368  +// #define TreeView_GetVisibleCount(hwnd) (UINT)SNDMSG((hwnd), TVM_GETVISIBLECOUNT, 0, 0)
         5369  +
         5370  +enum : uint { TVM_HITTEST = TV_FIRST + 17 }
         5371  +// #define TreeView_HitTest(hwnd, lpht) (HTREEITEM)SNDMSG((hwnd), TVM_HITTEST, 0, (LPARAM)(LPTV_HITTESTINFO)(lpht))
         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_ONITEMSTATEICON }
         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_CREATEDRAGIMAGE, 0, (LPARAM)(HTREEITEM)(hitem))
         5406  +
         5407  +enum : uint { TVM_SORTCHILDREN = TV_FIRST + 19 }
         5408  +// #define TreeView_SortChildren(hwnd, hitem, recurse) (BOOL)SNDMSG((hwnd), TVM_SORTCHILDREN, (WPARAM)(recurse), (LPARAM)(HTREEITEM)(hitem))
         5409  +
         5410  +enum : uint { TVM_ENSUREVISIBLE = TV_FIRST + 20 }
         5411  +// #define TreeView_EnsureVisible(hwnd, hitem) (BOOL)SNDMSG((hwnd), TVM_ENSUREVISIBLE, 0, (LPARAM)(HTREEITEM)(hitem))
         5412  +
         5413  +enum : uint { TVM_SORTCHILDRENCB = TV_FIRST + 21 }
         5414  +// #define TreeView_SortChildrenCB(hwnd, psort, recurse) (BOOL)SNDMSG((hwnd), TVM_SORTCHILDRENCB, (WPARAM)(recurse), (LPARAM)(LPTV_SORTCB)(psort))
         5415  +
         5416  +enum : uint { TVM_ENDEDITLABELNOW = TV_FIRST + 22 }
         5417  +// #define TreeView_EndEditLabelNow(hwnd, fCancel) (BOOL)SNDMSG((hwnd), TVM_ENDEDITLABELNOW, (WPARAM)(fCancel), 0)
         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_SETTOOLTIPS, (WPARAM)(hwndTT), 0)
         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_GETISEARCHSTRING, 0, (LPARAM)(LPTSTR)(lpsz))
         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_SETINSERTMARK, (WPARAM) (fAfter), (LPARAM) (hItem))
         5440  +
         5441  +alias CCM_SETUNICODEFORMAT TVM_SETUNICODEFORMAT;
         5442  +// #define TreeView_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), TVM_SETUNICODEFORMAT, (WPARAM)(fUnicode), 0)
         5443  +
         5444  +alias CCM_GETUNICODEFORMAT TVM_GETUNICODEFORMAT;
         5445  +// #define TreeView_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), TVM_GETUNICODEFORMAT, 0, 0)
         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_SETITEMHEIGHT, (WPARAM)(iHeight), 0)
         5452  +enum : uint { TVM_GETITEMHEIGHT = TV_FIRST + 28 }
         5453  +// #define TreeView_GetItemHeight(hwnd) (int)SNDMSG((hwnd), TVM_GETITEMHEIGHT, 0, 0)
         5454  +
         5455  +enum : uint { TVM_SETBKCOLOR = TV_FIRST + 29 }
         5456  +// #define TreeView_SetBkColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_SETBKCOLOR, 0, (LPARAM)(clr))
         5457  +
         5458  +enum : uint { TVM_SETTEXTCOLOR = TV_FIRST + 30 }
         5459  +// #define TreeView_SetTextColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_SETTEXTCOLOR, 0, (LPARAM)(clr))
         5460  +
         5461  +enum : uint { TVM_GETBKCOLOR = TV_FIRST + 31 }
         5462  +// #define TreeView_GetBkColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETBKCOLOR, 0, 0)
         5463  +
         5464  +enum : uint { TVM_GETTEXTCOLOR = TV_FIRST + 32 }
         5465  +// #define TreeView_GetTextColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETTEXTCOLOR, 0, 0)
         5466  +
         5467  +enum : uint { TVM_SETSCROLLTIME = TV_FIRST + 33 }
         5468  +// #define TreeView_SetScrollTime(hwnd, uTime) (UINT)SNDMSG((hwnd), TVM_SETSCROLLTIME, uTime, 0)
         5469  +
         5470  +enum : uint { TVM_GETSCROLLTIME = TV_FIRST + 34 }
         5471  +// #define TreeView_GetScrollTime(hwnd) (UINT)SNDMSG((hwnd), TVM_GETSCROLLTIME, 0, 0)
         5472  +
         5473  +enum : uint { TVM_SETINSERTMARKCOLOR = TV_FIRST + 37 }
         5474  +// #define TreeView_SetInsertMarkColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_SETINSERTMARKCOLOR, 0, (LPARAM)(clr))
         5475  +enum : uint { TVM_GETINSERTMARKCOLOR = TV_FIRST + 38 }
         5476  +// #define TreeView_GetInsertMarkColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETINSERTMARKCOLOR, 0, 0)
         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_TVi.mask = TVIF_STATE; _ms_TVi.hItem = hti; _ms_TVi.stateMask = _mask; _ms_TVi.state = data; SNDMSG((hwndTV), TVM_SETITEM, 0, (LPARAM)(TV_ITEM *)&_ms_TVi); }
         5483  +
         5484  +// #define TreeView_SetCheckState(hwndTV, hti, fCheck) TreeView_SetItemState(hwndTV, hti, INDEXTOSTATEIMAGEMASK((fCheck)?2:1), TVIS_STATEIMAGEMASK)
         5485  +
         5486  +enum : uint { TVM_GETITEMSTATE = TV_FIRST + 39 }
         5487  +// #define TreeView_GetItemState(hwndTV, hti, mask) (UINT)SNDMSG((hwndTV), TVM_GETITEMSTATE, (WPARAM)(hti), (LPARAM)(mask))
         5488  +
         5489  +// #define TreeView_GetCheckState(hwndTV, hti) ((((UINT)(SNDMSG((hwndTV), TVM_GETITEMSTATE, (WPARAM)(hti), TVIS_STATEIMAGEMASK))) >> 12) -1)
         5490  +
         5491  +enum : uint { TVM_SETLINECOLOR = TV_FIRST + 40 }
         5492  +// #define TreeView_SetLineColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), TVM_SETLINECOLOR, 0, (LPARAM)(clr))
         5493  +
         5494  +enum : uint { TVM_GETLINECOLOR = TV_FIRST + 41 }
         5495  +// #define TreeView_GetLineColor(hwnd) (COLORREF)SNDMSG((hwnd), TVM_GETLINECOLOR, 0, 0)
         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_MAPACCIDTOHTREEITEM, id, 0)
         5502  +
         5503  +enum : uint { TVM_MAPHTREEITEMTOACCID = TV_FIRST + 43 }
         5504  +// #define TreeView_MapHTREEITEMToAccID(hwnd, htreeitem) (UINT)SNDMSG((hwnd), TVM_MAPHTREEITEMTOACCID, (WPARAM)htreeitem, 0)
         5505  +
         5506  +// #endif
         5507  +
         5508  +extern(Windows) alias int function(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort) PFNTVCOMPARE;
         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_GETIMAGELIST, 0, 0L)
         6049  +
         6050  +enum : uint { TCM_SETIMAGELIST = TCM_FIRST + 3 }
         6051  +// #define TabCtrl_SetImageList(hwnd, himl) (HIMAGELIST)SNDMSG((hwnd), TCM_SETIMAGELIST, 0, (LPARAM)(HIMAGELIST)(himl))
         6052  +
         6053  +enum : uint { TCM_GETITEMCOUNT = TCM_FIRST + 4 }
         6054  +// #define TabCtrl_GetItemCount(hwnd) (int)SNDMSG((hwnd), TCM_GETITEMCOUNT, 0, 0L)
         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, (WPARAM)(int)(iItem), (LPARAM)(TC_ITEM *)(pitem))
         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, (WPARAM)(int)(iItem), (LPARAM)(TC_ITEM *)(pitem))
         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_INSERTITEM, (WPARAM)(int)(iItem), (LPARAM)(const TC_ITEM *)(pitem))
         6193  +
         6194  +enum : uint { TCM_DELETEITEM = TCM_FIRST + 8 }
         6195  +// #define TabCtrl_DeleteItem(hwnd, i) (BOOL)SNDMSG((hwnd), TCM_DELETEITEM, (WPARAM)(int)(i), 0L)
         6196  +
         6197  +enum : uint { TCM_DELETEALLITEMS = TCM_FIRST + 9 }
         6198  +// #define TabCtrl_DeleteAllItems(hwnd) (BOOL)SNDMSG((hwnd), TCM_DELETEALLITEMS, 0, 0L)
         6199  +
         6200  +enum : uint { TCM_GETITEMRECT = TCM_FIRST + 10 }
         6201  +// #define TabCtrl_GetItemRect(hwnd, i, prc) (BOOL)SNDMSG((hwnd), TCM_GETITEMRECT, (WPARAM)(int)(i), (LPARAM)(RECT *)(prc))
         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)(i), 0)
         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, (LPARAM)(TC_HITTESTINFO *)(pinfo))
         6232  +
         6233  +enum : uint { TCM_SETITEMEXTRA = TCM_FIRST + 14 }
         6234  +// #define TabCtrl_SetItemExtra(hwndTC, cb) (BOOL)SNDMSG((hwndTC), TCM_SETITEMEXTRA, (WPARAM)(cb), 0L)
         6235  +
         6236  +enum : uint { TCM_ADJUSTRECT = TCM_FIRST + 40 }
         6237  +// #define TabCtrl_AdjustRect(hwnd, bLarger, prc) (int)SNDMSG(hwnd, TCM_ADJUSTRECT, (WPARAM)(BOOL)(bLarger), (LPARAM)(RECT *)prc)
         6238  +
         6239  +enum : uint { TCM_SETITEMSIZE = TCM_FIRST + 41 }
         6240  +// #define TabCtrl_SetItemSize(hwnd, x, y) (DWORD)SNDMSG((hwnd), TCM_SETITEMSIZE, 0, MAKELPARAM(x,y))
         6241  +
         6242  +enum : uint { TCM_REMOVEIMAGE = TCM_FIRST + 42 }
         6243  +// #define TabCtrl_RemoveImage(hwnd, i) (void)SNDMSG((hwnd), TCM_REMOVEIMAGE, i, 0L)
         6244  +
         6245  +enum : uint { TCM_SETPADDING = TCM_FIRST + 43 }
         6246  +// #define TabCtrl_SetPadding(hwnd, cx, cy) (void)SNDMSG((hwnd), TCM_SETPADDING, 0, MAKELPARAM(cx, cy))
         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_SETTOOLTIPS, (WPARAM)(hwndTT), 0L)
         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_SETMINTABWIDTH, 0, x)
         6266  +
         6267  +enum : uint { TCM_DESELECTALL = TCM_FIRST + 50 }
         6268  +// #define TabCtrl_DeselectAll(hwnd, fExcludeFocus) (void)SNDMSG((hwnd), TCM_DESELECTALL, fExcludeFocus, 0)
         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_HIGHLIGHTITEM, (WPARAM)(i), (LPARAM)MAKELONG (fHighlight, 0))
         6275  +
         6276  +enum : uint { TCM_SETEXTENDEDSTYLE = TCM_FIRST + 52 }
         6277  +// #define TabCtrl_SetExtendedStyle(hwnd, dw) (DWORD)SNDMSG((hwnd), TCM_SETEXTENDEDSTYLE, 0, dw)
         6278  +
         6279  +enum : uint { TCM_GETEXTENDEDSTYLE = TCM_FIRST + 53 }
         6280  +// #define TabCtrl_GetExtendedStyle(hwnd) (DWORD)SNDMSG((hwnd), TCM_GETEXTENDEDSTYLE, 0, 0)
         6281  +
         6282  +alias CCM_SETUNICODEFORMAT TCM_SETUNICODEFORMAT;
         6283  +// #define TabCtrl_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), TCM_SETUNICODEFORMAT, (WPARAM)(fUnicode), 0)
         6284  +
         6285  +alias CCM_GETUNICODEFORMAT TCM_GETUNICODEFORMAT;
         6286  +// #define TabCtrl_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), TCM_GETUNICODEFORMAT, 0, 0)
         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_CLASS, NULL, dwStyle, 0, 0, 0, 0, hwndP, (HMENU)(id), hInstance, NULL)
         6360  +
         6361  +// #define Animate_Open(hwnd, szName) (BOOL)SNDMSG(hwnd, ACM_OPEN, 0, (LPARAM)(LPTSTR)(szName))
         6362  +// #define Animate_OpenEx(hwnd, hInst, szName) (BOOL)SNDMSG(hwnd, ACM_OPEN, (WPARAM)(hInst), (LPARAM)(LPTSTR)(szName))
         6363  +// #define Animate_Play(hwnd, from, to, rep) (BOOL)SNDMSG(hwnd, ACM_PLAY, (WPARAM)(rep), (LPARAM)MAKELONG(from, to))
         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, (LPARAM)(pst))
         6392  +
         6393  +enum : uint { MCM_SETCURSEL = MCM_FIRST + 2 }
         6394  +// #define MonthCal_SetCurSel(hmc, pst) (BOOL)SNDMSG(hmc, MCM_SETCURSEL, 0, (LPARAM)(pst))
         6395  +
         6396  +enum : uint { MCM_GETMAXSELCOUNT = MCM_FIRST + 3 }
         6397  +// #define MonthCal_GetMaxSelCount(hmc) (DWORD)SNDMSG(hmc, MCM_GETMAXSELCOUNT, 0, 0L)
         6398  +
         6399  +enum : uint { MCM_SETMAXSELCOUNT = MCM_FIRST + 4 }
         6400  +// #define MonthCal_SetMaxSelCount(hmc, n) (BOOL)SNDMSG(hmc, MCM_SETMAXSELCOUNT, (WPARAM)(n), 0L)
         6401  +
         6402  +enum : uint { MCM_GETSELRANGE = MCM_FIRST + 5 }
         6403  +// #define MonthCal_GetSelRange(hmc, rgst) SNDMSG(hmc, MCM_GETSELRANGE, 0, (LPARAM)(rgst))
         6404  +
         6405  +enum : uint { MCM_SETSELRANGE = MCM_FIRST + 6 }
         6406  +// #define MonthCal_SetSelRange(hmc, rgst) SNDMSG(hmc, MCM_SETSELRANGE, 0, (LPARAM)(rgst))
         6407  +
         6408  +enum : uint { MCM_GETMONTHRANGE = MCM_FIRST + 7 }
         6409  +// #define MonthCal_GetMonthRange(hmc, gmr, rgst) (DWORD)SNDMSG(hmc, MCM_GETMONTHRANGE, (WPARAM)(gmr), (LPARAM)(rgst))
         6410  +
         6411  +enum : uint { MCM_SETDAYSTATE = MCM_FIRST + 8 }
         6412  +// #define MonthCal_SetDayState(hmc, cbds, rgds) SNDMSG(hmc, MCM_SETDAYSTATE, (WPARAM)(cbds), (LPARAM)(rgds))
         6413  +
         6414  +enum : uint { MCM_GETMINREQRECT = MCM_FIRST + 9 }
         6415  +// #define MonthCal_GetMinReqRect(hmc, prc) SNDMSG(hmc, MCM_GETMINREQRECT, 0, (LPARAM)(prc))
         6416  +
         6417  +enum : uint { MCM_SETCOLOR = MCM_FIRST + 10 }
         6418  +// #define MonthCal_SetColor(hmc, iColor, clr) SNDMSG(hmc, MCM_SETCOLOR, iColor, clr)
         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, (LPARAM)(pst))
         6435  +
         6436  +enum : uint { MCM_HITTEST = MCM_FIRST + 14 }
         6437  +// #define MonthCal_HitTest(hmc, pinfo) SNDMSG(hmc, MCM_HITTEST, 0, (LPARAM)(PMCHITTESTINFO)(pinfo))
         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_SETFIRSTDAYOFWEEK, 0, iDay)
         6472  +
         6473  +enum : uint { MCM_GETFIRSTDAYOFWEEK = MCM_FIRST + 16 }
         6474  +// #define MonthCal_GetFirstDayOfWeek(hmc) (DWORD)SNDMSG(hmc, MCM_GETFIRSTDAYOFWEEK, 0, 0)
         6475  +
         6476  +enum : uint { MCM_GETRANGE = MCM_FIRST + 17 }
         6477  +// #define MonthCal_GetRange(hmc, rgst) (DWORD)SNDMSG(hmc, MCM_GETRANGE, 0, (LPARAM)(rgst))
         6478  +
         6479  +enum : uint { MCM_SETRANGE = MCM_FIRST + 18 }
         6480  +// #define MonthCal_SetRange(hmc, gd, rgst) (BOOL)SNDMSG(hmc, MCM_SETRANGE, (WPARAM)(gd), (LPARAM)(rgst))
         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, 0)
         6487  +
         6488  +enum : uint { MCM_GETMAXTODAYWIDTH = MCM_FIRST + 21 }
         6489  +// #define MonthCal_GetMaxTodayWidth(hmc) (DWORD)SNDMSG(hmc, MCM_GETMAXTODAYWIDTH, 0, 0)
         6490  +
         6491  +// #if (_WIN32_IE >= 0x0400)
         6492  +alias CCM_SETUNICODEFORMAT MCM_SETUNICODEFORMAT;
         6493  +// #define MonthCal_SetUnicodeFormat(hwnd, fUnicode) (BOOL)SNDMSG((hwnd), MCM_SETUNICODEFORMAT, (WPARAM)(fUnicode), 0)
         6494  +
         6495  +alias CCM_GETUNICODEFORMAT MCM_GETUNICODEFORMAT;
         6496  +// #define MonthCal_GetUnicodeFormat(hwnd) (BOOL)SNDMSG((hwnd), MCM_GETUNICODEFORMAT, 0, 0)
         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, 0, (LPARAM)(pst))
         6559  +
         6560  +enum : uint { DTM_SETSYSTEMTIME = DTM_FIRST + 2 }
         6561  +// #define DateTime_SetSystemtime(hdp, gd, pst) (BOOL)SNDMSG(hdp, DTM_SETSYSTEMTIME, (WPARAM)(gd), (LPARAM)(pst))
         6562  +
         6563  +enum : uint { DTM_GETRANGE = DTM_FIRST + 3 }
         6564  +// #define DateTime_GetRange(hdp, rgst) (DWORD)SNDMSG(hdp, DTM_GETRANGE, 0, (LPARAM)(rgst))
         6565  +
         6566  +enum : uint { DTM_SETRANGE = DTM_FIRST + 4 }
         6567  +// #define DateTime_SetRange(hdp, gd, rgst) (BOOL)SNDMSG(hdp, DTM_SETRANGE, (WPARAM)(gd), (LPARAM)(rgst))
         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, (LPARAM)(sz))
         6579  +
         6580  +enum : uint { DTM_SETMCCOLOR = DTM_FIRST + 6 }
         6581  +// #define DateTime_SetMonthCalColor(hdp, iColor, clr) SNDMSG(hdp, DTM_SETMCCOLOR, iColor, clr)
         6582  +
         6583  +enum : uint { DTM_GETMCCOLOR = DTM_FIRST + 7 }
         6584  +// #define DateTime_GetMonthCalColor(hdp, iColor) SNDMSG(hdp, DTM_GETMCCOLOR, iColor, 0)
         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_SETMCFONT, (WPARAM)(hfont), (LPARAM)(fRedraw))
         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)(low)))
         6782  +
         6783  +// #define MAKEIPADDRESS(b1,b2,b3,b4) ((LPARAM)(((DWORD)(b1)<<24)+((DWORD)(b2)<<16)+((DWORD)(b3)<<8)+((DWORD)(b4))))
         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, (LPARAM)(hwndChild))
         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_FORWARDMOUSE, (WPARAM)(bForward), 0)
         6825  +
         6826  +enum : uint { PGM_SETBKCOLOR = PGM_FIRST + 4 }
         6827  +// #define Pager_SetBkColor(hwnd, clr) (COLORREF)SNDMSG((hwnd), PGM_SETBKCOLOR, 0, (LPARAM)(clr))
         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, (LPARAM)(iBorder))
         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)(iPos))
         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_SETBUTTONSIZE, 0, (LPARAM)(iSize))
         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_GETBUTTONSTATE, 0, (LPARAM)(iButton))
         6852  +
         6853  +alias CCM_GETDROPTARGET PGM_GETDROPTARGET;
         6854  +// #define Pager_GetDropTarget(hwnd, ppdt) (void)SNDMSG((hwnd), PGM_GETDROPTARGET, 0, (LPARAM)(ppdt))
         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_GETIDEALSIZE, 0, (LPARAM)(psize))
         6968  +
         6969  +enum : uint { BCM_SETIMAGELIST = BCM_FIRST + 0x0002 }
         6970  +// #define Button_SetImageList(hwnd, pbuttonImagelist) (BOOL)SNDMSG((hwnd), BCM_SETIMAGELIST, 0, (LPARAM)(pbuttonImagelist))
         6971  +
         6972  +enum : uint { BCM_GETIMAGELIST = BCM_FIRST + 0x0003 }
         6973  +// #define Button_GetImageList(hwnd, pbuttonImagelist) (BOOL)SNDMSG((hwnd), BCM_GETIMAGELIST, 0, (LPARAM)(pbuttonImagelist))
         6974  +
         6975  +enum : uint { BCM_SETTEXTMARGIN = BCM_FIRST + 0x0004 }
         6976  +// #define Button_SetTextMargin(hwnd, pmargin) (BOOL)SNDMSG((hwnd), BCM_SETTEXTMARGIN, 0, (LPARAM)(pmargin))
         6977  +enum : uint { BCM_GETTEXTMARGIN = BCM_FIRST + 0x0005 }
         6978  +// #define Button_GetTextMargin(hwnd, pmargin) (BOOL)SNDMSG((hwnd), BCM_GETTEXTMARGIN, 0, (LPARAM)(pmargin))
         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_SETCUEBANNER, 0, (LPARAM)(lpcwText))
         7034  +enum : uint { EM_GETCUEBANNER = ECM_FIRST + 2 }
         7035  +// #define Edit_GetCueBannerText(hwnd, lpwText, cchText) (BOOL)SNDMSG((hwnd), EM_GETCUEBANNER, (WPARAM)(lpwText), (LPARAM)(cchText))
         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_SHOWBALLOONTIP, 0, (LPARAM)(peditballoontip))
         7048  +enum : uint { EM_HIDEBALLOONTIP = ECM_FIRST + 4 }
         7049  +// #define Edit_HideBalloonTip(hwnd) (BOOL)SNDMSG((hwnd), EM_HIDEBALLOONTIP, 0, 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_SETMINVISIBLE, (WPARAM)iMinVisible, 0)
         7098  +
         7099  +// #define ComboBox_GetMinVisible(hwnd) (int)SNDMSG((hwnd), CB_GETMINVISIBLE, 0, 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 fRedraw);
         7259  +
         7260  +extern(Windows) export int FlatSB_SetScrollInfo(HWND, int code, LPSCROLLINFO, BOOL fRedraw);
         7261  +
         7262  +extern(Windows) export int FlatSB_SetScrollRange(HWND, int code, int min, int max, BOOL fRedraw);
         7263  +extern(Windows) export BOOL FlatSB_SetScrollProp(HWND, UINT index, INT_PTR newValue, BOOL);
         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, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) SUBCLASSPROC;
         7280  +
         7281  +extern(Windows) export BOOL SetWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass,
         7282  +  DWORD_PTR dwRefData);
         7283  +extern(Windows) export BOOL GetWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass,
         7284  +  DWORD_PTR *pdwRefData);
         7285  +extern(Windows) export BOOL RemoveWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclass,
         7286  +  UINT_PTR uIdSubclass);
         7287  +
         7288  +extern(Windows) export LRESULT DefSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
         7289  +// #endif
         7290  +
         7291  +// #if (_WIN32_WINNT >= 0x501)
         7292  +
         7293  +extern(Windows) export int DrawShadowText(HDC hdc, LPCWSTR pszText, UINT cch, RECT* prc, DWORD dwFlags, COLORREF crText, COLORREF crShadow,
         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  +