/******************************Module*Header*******************************\
* Module Name: ftalpha.cxx
*
*
*
* Copyright (c) 1990 Microsoft Corporation
\**************************************************************************/

#include "precomp.h"
#pragma hdrstop



/**************************************************************************\
* hCreateAlphaStretchDIB
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/8/1997 Mark Enstrom [marke]
*
\**************************************************************************/

#define FORMAT_ALPHA  0x01
#define FORMAT_32_RGB 0x02
#define FORMAT_32_GRB 0x04
#define FORMAT_16_555 0x08
#define FORMAT_16_565 0x10
#define FORMAT_16_664 0x20

//
// translate RGB [3 3 2] into halftone palette index
//

BYTE gHalftoneColorXlate332[] = {
    0x00,0x5f,0x85,0xfc,0x21,0x65,0xa6,0xfc,0x21,0x65,0xa6,0xcd,0x27,0x6b,0x8a,0xcd,
    0x2d,0x70,0x81,0xd3,0x33,0x76,0x95,0xd9,0x33,0x76,0x95,0xd9,0xfa,0x7b,0x9b,0xfe,
    0x1d,0x60,0xa2,0xfc,0x22,0x66,0x86,0xc8,0x22,0x66,0x86,0xc8,0x28,0x6c,0x8b,0xce,
    0x2e,0x71,0x90,0xd4,0x34,0x77,0x96,0xda,0x34,0x77,0x96,0xda,0xfa,0x7c,0x9c,0xdf,
    0x1d,0x60,0xa2,0xc5,0x22,0x66,0x86,0xc8,0x22,0x13,0x86,0xc8,0x28,0x12,0x8b,0xce,
    0x2e,0x71,0x90,0xd4,0x34,0x77,0x96,0xda,0x34,0x77,0x96,0xda,0x39,0x7c,0x9c,0xdf,
    0x1e,0x61,0x87,0xc5,0x23,0x67,0x8c,0xc9,0x23,0x12,0x8c,0xc9,0x29,0x6d,0xae,0xe6,
    0x2f,0x72,0x91,0xd5,0x35,0x97,0x9d,0xdb,0x35,0x97,0x9d,0xdb,0x39,0xe4,0xc0,0xe8,

    0x1f,0x62,0x83,0xc6,0x24,0x68,0x82,0xca,0x24,0x68,0x82,0xca,0x2a,0x6e,0x8d,0xd0,
    0x30,0x73,0x92,0xd6,0x36,0x78,0xf7,0xdc,0x36,0x78,0x98,0xdc,0x3a,0x7d,0x9e,0xe1,
    0x20,0x63,0x84,0x80,0x25,0x69,0x88,0xcb,0x25,0x69,0x88,0xcb,0x2b,0x6f,0x8e,0xd1,
    0x31,0x74,0xf7,0xd7,0x37,0x79,0xef,0x09,0x37,0x79,0x08,0xdd,0x3b,0x7e,0x9f,0xe2,
    0x20,0x63,0x84,0x80,0x25,0x69,0x88,0xcb,0x25,0x69,0x88,0xcb,0x2b,0x6f,0x8e,0xd1,
    0x31,0x74,0x93,0xd7,0x37,0x79,0x99,0xdd,0x37,0x79,0x99,0xdd,0x3b,0x7e,0x9f,0xe2,
    0xf9,0x64,0x89,0xfd,0x26,0x6a,0x8f,0xcc,0x26,0x17,0x8f,0xcc,0x2c,0xe3,0xb1,0xe7,
    0x32,0x75,0x94,0xd8,0x38,0x7a,0x9a,0xde,0x38,0x7a,0x9a,0xde,0xfb,0xe5,0xa0,0xff
    };

//
// inter-test delay
//

ULONG  gAlphaSleep = 100;

ULONG DefPalette[20] = { 0x00000000,0x00000080,0x00008000,0x00008080,
                         0x00800000,0x00800080,0x00808000,0x00c0c0c0,
                         0x00c0dcc0,0x00f0caa6,0x00f0fbff,0x00a4a0a0,
                         0x00808080,0x000000ff,0x0000ff00,0x0000ffff,
                         0x00ff0000,0x00ff00ff,0x00ffff00,0x00ffffff
                       };
ULONG DefPaletteRGBQUAD[20] = { 0x00000000,0x00800000,0x00008000,0x00808000,
                                0x00000080,0x00800080,0x00008080,0x00c0c0c0,
                                0x00c0dcc0,0x00a6caf0,0x00fffbf0,0x00a0a0a4,
                                0x00808080,0x00ff0000,0x0000ff00,0x00ffff00,
                                0x000000ff,0x00ff00ff,0x0000ffff,0x00ffffff
                              };

ULONG htPalette[256] = {
     0x00000000,0x00000080,0x00008000,0x00008080,
     0x00800000,0x00800080,0x00808000,0x00c0c0c0,
     0x00c0dcc0,0x00f0caa6,0x04040404,0x04080808,
     0x040c0c0c,0x04111111,0x04161616,0x041c1c1c,
     0x04222222,0x04292929,0x04555555,0x044d4d4d,
     0x04424242,0x04393939,0x04807CFF,0x045050FF,
     0x049300D6,0x04FFECCC,0x04C6D6EF,0x04D6E7E7,
     0x0490A9AD,0x04000033,0x04000066,0x04000099,
     0x040000cc,0x04003300,0x04003333,0x04003366,
     0x04003399,0x040033cc,0x040033ff,0x04006600,
     0x04006633,0x04006666,0x04006699,0x040066cc,
     0x040066ff,0x04009900,0x04009933,0x04009966,
     0x04009999,0x040099cc,0x040099ff,0x0400cc00,
     0x0400cc33,0x0400cc66,0x0400cc99,0x0400cccc,
     0x0400ccff,0x0400ff66,0x0400ff99,0x0400ffcc,
     0x04330000,0x04330033,0x04330066,0x04330099,
     0x043300cc,0x043300ff,0x04333300,0x04333333,
     0x04333366,0x04333399,0x043333cc,0x043333ff,
     0x04336600,0x04336633,0x04336666,0x04336699,
     0x043366cc,0x043366ff,0x04339900,0x04339933,
     0x04339966,0x04339999,0x043399cc,0x043399ff,
     0x0433cc00,0x0433cc33,0x0433cc66,0x0433cc99,
     0x0433cccc,0x0433ccff,0x0433ff33,0x0433ff66,
     0x0433ff99,0x0433ffcc,0x0433ffff,0x04660000,
     0x04660033,0x04660066,0x04660099,0x046600cc,
     0x046600ff,0x04663300,0x04663333,0x04663366,
     0x04663399,0x046633cc,0x046633ff,0x04666600,
     0x04666633,0x04666666,0x04666699,0x046666cc,
     0x04669900,0x04669933,0x04669966,0x04669999,
     0x046699cc,0x046699ff,0x0466cc00,0x0466cc33,
     0x0466cc99,0x0466cccc,0x0466ccff,0x0466ff00,
     0x0466ff33,0x0466ff99,0x0466ffcc,0x04cc00ff,
     0x04ff00cc,0x04999900,0x04993399,0x04990099,
     0x049900cc,0x04990000,0x04993333,0x04990066,
     0x049933cc,0x049900ff,0x04996600,0x04996633,
     0x04993366,0x04996699,0x049966cc,0x049933ff,
     0x04999933,0x04999966,0x04999999,0x049999cc,
     0x049999ff,0x0499cc00,0x0499cc33,0x0466cc66,
     0x0499cc99,0x0499cccc,0x0499ccff,0x0499ff00,
     0x0499ff33,0x0499cc66,0x0499ff99,0x0499ffcc,
     0x0499ffff,0x04cc0000,0x04990033,0x04cc0066,
     0x04cc0099,0x04cc00cc,0x04993300,0x04cc3333,
     0x04cc3366,0x04cc3399,0x04cc33cc,0x04cc33ff,
     0x04cc6600,0x04cc6633,0x04996666,0x04cc6699,
     0x04cc66cc,0x049966ff,0x04cc9900,0x04cc9933,
     0x04cc9966,0x04cc9999,0x04cc99cc,0x04cc99ff,
     0x04cccc00,0x04cccc33,0x04cccc66,0x04cccc99,
     0x04cccccc,0x04ccccff,0x04ccff00,0x04ccff33,
     0x0499ff66,0x04ccff99,0x04ccffcc,0x04ccffff,
     0x04cc0033,0x04ff0066,0x04ff0099,0x04cc3300,
     0x04ff3333,0x04ff3366,0x04ff3399,0x04ff33cc,
     0x04ff33ff,0x04ff6600,0x04ff6633,0x04cc6666,
     0x04ff6699,0x04ff66cc,0x04cc66ff,0x04ff9900,
     0x04ff9933,0x04ff9966,0x04ff9999,0x04ff99cc,
     0x04ff99ff,0x04ffcc00,0x04ffcc33,0x04ffcc66,
     0x04ffcc99,0x04ffcccc,0x04ffccff,0x04ffff33,
     0x04ccff66,0x04ffff99,0x04ffffcc,0x046666ff,
     0x0466ff66,0x0466ffff,0x04ff6666,0x04ff66ff,
     0x04ffff66,0x042100A5,0x045f5f5f,0x04777777,
     0x04868686,0x04969696,0x04cbcbcb,0x04b2b2b2,
     0x04d7d7d7,0x04dddddd,0x04e3e3e3,0x04eaeaea,
     0x04f1f1f1,0x04f8f8f8,0x00f0fbff,0x00a4a0a0,
     0x00808080,0x000000ff,0x0000ff00,0x0000ffff,
     0x00ff0000,0x00ff00ff,0x00ffff00,0x00ffffff
     };

ULONG htPaletteRGBQUAD[256] = {
     0x00000000,0x00800000,0x00008000,0x00808000,
     0x00000080,0x00800080,0x00008080,0x00c0c0c0,
     0x00c0dcc0,0x00a6caf0,0x04040404,0x04080808,
     0x040c0c0c,0x04111111,0x04161616,0x041c1c1c,
     0x04222222,0x04292929,0x04555555,0x044d4d4d,
     0x04424242,0x04393939,0x04FF7C80,0x04FF5050,
     0x04D60093,0x04CCECFF,0x04EFD6C6,0x04E7E7D6,
     0x04ADA990,0x04330000,0x04660000,0x04990000,
     0x04cc0000,0x04003300,0x04333300,0x04663300,
     0x04993300,0x04cc3300,0x04ff3300,0x04006600,
     0x04336600,0x04666600,0x04996600,0x04cc6600,
     0x04ff6600,0x04009900,0x04339900,0x04669900,
     0x04999900,0x04cc9900,0x04ff9900,0x0400cc00,
     0x0433cc00,0x0466cc00,0x0499cc00,0x04cccc00,
     0x04ffcc00,0x0466ff00,0x0499ff00,0x04ccff00,
     0x04000033,0x04330033,0x04660033,0x04990033,
     0x04cc0033,0x04ff0033,0x04003333,0x04333333,
     0x04663333,0x04993333,0x04cc3333,0x04ff3333,
     0x04006633,0x04336633,0x04666633,0x04996633,
     0x04cc6633,0x04ff6633,0x04009933,0x04339933,
     0x04669933,0x04999933,0x04cc9933,0x04ff9933,
     0x0400cc33,0x0433cc33,0x0466cc33,0x0499cc33,
     0x04cccc33,0x04ffcc33,0x0433ff33,0x0466ff33,
     0x0499ff33,0x04ccff33,0x04ffff33,0x04000066,
     0x04330066,0x04660066,0x04990066,0x04cc0066,
     0x04ff0066,0x04003366,0x04333366,0x04663366,
     0x04993366,0x04cc3366,0x04ff3366,0x04006666,
     0x04336666,0x04666666,0x04996666,0x04cc6666,
     0x04009966,0x04339966,0x04669966,0x04999966,
     0x04cc9966,0x04ff9966,0x0400cc66,0x0433cc66,
     0x0499cc66,0x04cccc66,0x04ffcc66,0x0400ff66,
     0x0433ff66,0x0499ff66,0x04ccff66,0x04ff00cc,
     0x04cc00ff,0x04009999,0x04993399,0x04990099,
     0x04cc0099,0x04000099,0x04333399,0x04660099,
     0x04cc3399,0x04ff0099,0x04006699,0x04336699,
     0x04663399,0x04996699,0x04cc6699,0x04ff3399,
     0x04339999,0x04669999,0x04999999,0x04cc9999,
     0x04ff9999,0x0400cc99,0x0433cc99,0x0466cc66,
     0x0499cc99,0x04cccc99,0x04ffcc99,0x0400ff99,
     0x0433ff99,0x0466cc99,0x0499ff99,0x04ccff99,
     0x04ffff99,0x040000cc,0x04330099,0x046600cc,
     0x049900cc,0x04cc00cc,0x04003399,0x043333cc,
     0x046633cc,0x049933cc,0x04cc33cc,0x04ff33cc,
     0x040066cc,0x043366cc,0x04666699,0x049966cc,
     0x04cc66cc,0x04ff6699,0x040099cc,0x043399cc,
     0x046699cc,0x049999cc,0x04cc99cc,0x04ff99cc,
     0x0400cccc,0x0433cccc,0x0466cccc,0x0499cccc,
     0x04cccccc,0x04ffcccc,0x0400ffcc,0x0433ffcc,
     0x0466ff99,0x0499ffcc,0x04ccffcc,0x04ffffcc,
     0x043300cc,0x046600ff,0x049900ff,0x040033cc,
     0x043333ff,0x046633ff,0x049933ff,0x04cc33ff,
     0x04ff33ff,0x040066ff,0x043366ff,0x046666cc,
     0x049966ff,0x04cc66ff,0x04ff66cc,0x040099ff,
     0x043399ff,0x046699ff,0x049999ff,0x04cc99ff,
     0x04ff99ff,0x0400ccff,0x0433ccff,0x0466ccff,
     0x0499ccff,0x04ccccff,0x04ffccff,0x0433ffff,
     0x0466ffcc,0x0499ffff,0x04ccffff,0x04ff6666,
     0x0466ff66,0x04ffff66,0x046666ff,0x04ff66ff,
     0x0466ffff,0x04A50021,0x045f5f5f,0x04777777,
     0x04868686,0x04969696,0x04cbcbcb,0x04b2b2b2,
     0x04d7d7d7,0x04dddddd,0x04e3e3e3,0x04eaeaea,
     0x04f1f1f1,0x04f8f8f8,0x00fffbf0,0x00a0a0a4,
     0x00808080,0x00ff0000,0x0000ff00,0x00ffff00,
     0x000000ff,0x00ff00ff,0x0000ffff,0x00ffffff
     };


ULONG    ulBpp[] = {          32,           32,            32,24,           16,           16,           16,8,4,1,0};
ULONG    ulFor[] = {FORMAT_ALPHA,FORMAT_32_RGB, FORMAT_32_GRB, 0,FORMAT_16_555,FORMAT_16_565,FORMAT_16_664,0,0,0,0};
PCHAR    pFormatStr[] = {
                        " 32 bpp RGBA",
                        " 32 bpp RGB",
                        " 32 bpp GRB",
                        " 24 bpp",
                        " 16 bpp 555",
                        " 16 bpp 565",
                        " 16 BPP 664",
                        "  8 bpp DIB_RGB_COLORS",
                        "  4 bpp DIB_RGB_COLORS",
                        "  1 bpp DIB_RGB_COLORS",
                        };

ULONG    ulBppDIB[] = {          32,32,24,           16,           16,8,8,4,4,1,1,0};
ULONG    ulForDIB[] = {FORMAT_ALPHA, 0, 0,FORMAT_16_555,FORMAT_16_565,0,1,0,1,0,1,0};

PCHAR    pFormatStrDIB[] = {
                        " 32 bpp RGBA",
                        " 32 bpp no Alpha",
                        " 24 bpp",
                        " 16 bpp 555",
                        " 16 bpp 565",
                        "  8 bpp DIB_RGB_COLORS",
                        "  8 bpp DIB_PAL_COLORS",
                        "  4 bpp DIB_RGB_COLORS",
                        "  4 bpp DIB_PAL_COLORS",
                        "  1 bpp DIB_RGB_COLORS",
                        "  1 bpp DIB_PAL_COLORS"
                        };

/**************************************************************************\
* hCreateAlphaStretchBitmap - create and init DIBSection based on input
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/9/1997 Mark Enstrom [marke]
*
\**************************************************************************/

HBITMAP
hCreateAlphaStretchBitmap(
    HDC   hdc,
    ULONG BitsPerPixel,
    ULONG ColorFormat,
    ULONG  xDib,
    ULONG  yDib
    )
{
    PBITMAPINFO pbmi;
    ULONG       ux,uy;
    PULONG      pDib;
    HBITMAP     hdib = NULL;
    LONG        Compression = BI_RGB;

    pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));

    if (pbmi)
    {
        PULONG pulMask = (PULONG)&pbmi->bmiColors[0];

        //
        // prepare compression and color table
        //

        if ((BitsPerPixel == 32) && (ColorFormat & FORMAT_32_RGB))
        {
            pulMask[0] = 0x0000ff;
            pulMask[1] = 0x00ff00;
            pulMask[2] = 0xff0000;
            Compression = BI_BITFIELDS;
        }
        else if ((BitsPerPixel == 32) && ((ColorFormat & FORMAT_32_GRB)))
        {
            pulMask[0] = 0x00ff00;
            pulMask[1] = 0xff0000;
            pulMask[2] = 0x0000ff;
            Compression = BI_BITFIELDS;
        }
        else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_565))
        {
            pulMask[0] = 0xf800;
            pulMask[1] = 0x07e0;
            pulMask[2] = 0x001f;
            Compression = BI_BITFIELDS;
        }
        else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_555))
        {
            pulMask[0] = 0x7c00;
            pulMask[1] = 0x03e0;
            pulMask[2] = 0x001f;
            Compression = BI_BITFIELDS;
        }
        else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_664))
        {
            pulMask[0] = 0xFC00;
            pulMask[1] = 0x03F0;
            pulMask[2] = 0x000f;
            Compression = BI_BITFIELDS;
        }
        else if (BitsPerPixel == 8)
        {
            ULONG ulIndex;

            for (ulIndex=0;ulIndex<256;ulIndex++)
            {
                pulMask[ulIndex] = htPaletteRGBQUAD[ulIndex];
            }
        }
        else if (BitsPerPixel == 4)
        {
            ULONG ulIndex;

            for (ulIndex=0;ulIndex<8;ulIndex++)
            {
                pulMask[ulIndex]    = DefPaletteRGBQUAD[ulIndex];
                pulMask[15-ulIndex] = DefPaletteRGBQUAD[19-ulIndex];
            }
        }
        else if (BitsPerPixel == 1)
        {
            pulMask[0] = DefPaletteRGBQUAD[0];
            pulMask[1] = DefPaletteRGBQUAD[19];
        }

        //
        // create DIB
        //

        pbmi->bmiHeader.biSize            = sizeof(BITMAPINFOHEADER);
        pbmi->bmiHeader.biWidth           = xDib;
        pbmi->bmiHeader.biHeight          = yDib;
        pbmi->bmiHeader.biPlanes          = 1;
        pbmi->bmiHeader.biBitCount        = (USHORT)BitsPerPixel;
        pbmi->bmiHeader.biCompression     = Compression;
        pbmi->bmiHeader.biSizeImage       = 0;
        pbmi->bmiHeader.biXPelsPerMeter   = 0;
        pbmi->bmiHeader.biYPelsPerMeter   = 0;
        pbmi->bmiHeader.biClrUsed         = 0;
        pbmi->bmiHeader.biClrImportant    = 0;

        hdib  = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);

        if (hdib == NULL)
        {
            CHAR tmsg[256];

            //wsprintf(tmsg,"Format = %libpp, Comp = %li",BitsPerPixel,Compression);
            //MessageBox(NULL,"Can't create stretch DIBSECTION",tmsg,MB_OK);
        }
        else
        {

            //
            // init 32 bpp dib
            //

            if ((BitsPerPixel == 32) && (ColorFormat & FORMAT_ALPHA))
            {
                PULONG ptmp = pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        BYTE alpha = 0xff;
                        *ptmp++ = (alpha << 24) | (red << 16) | (green << 8) | (blue);
                    }
                }
            }
            else if ((BitsPerPixel == 32) && (ColorFormat & FORMAT_32_RGB))
            {
                PULONG ptmp = pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        *ptmp++ = (blue << 16) | (green << 8) | (red);
                    }
                }
            }
            else if ((BitsPerPixel == 32) && (ColorFormat & FORMAT_32_GRB))
            {
                PULONG ptmp = pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        *ptmp++ = (blue) | (red << 8) | (green << 16);
                    }
                }
            }
            else if (BitsPerPixel == 24)
            {
                PBYTE ptmp  = (PBYTE)pDib;
                PBYTE pscan = ptmp;
                LONG  Delta = ((yDib * 3) + 3) & ~3;

                //
                // since scan line is 128, alignment works. If width changes, this breaks
                //

                for (uy=0;uy<yDib;uy++)
                {
                    ptmp = pscan;
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        *ptmp++ = (blue);
                        *ptmp++ = (green);
                        *ptmp++ = (red);
                    }
                    pscan += Delta;
                }
            }
            else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_565))
            {
                PUSHORT ptmp = (PUSHORT)pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        BYTE alpha = 0xff;
                        *ptmp++ = ((red & 0xf8)   << 8) |
                                  ((green & 0xfc) << 3) |
                                  (blue >> 3);
                    }
                }
            }
            else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_555))
            {
                PUSHORT ptmp = (PUSHORT)pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        BYTE alpha = 0xff;
                        *ptmp++ = ((red & 0xf8)   << 7) |
                                  ((green & 0xf8) << 2) |
                                  (blue >> 3);
                    }
                }
            }
            else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_664))
            {
                PUSHORT ptmp = (PUSHORT)pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        BYTE alpha = 0xff;
                        *ptmp++ = ((red & 0xfc)   << 8) |
                                  ((green & 0xfc) << 2) |
                                  (blue >> 4);
                    }
                }
            }
            else if (BitsPerPixel == 8)
            {
                PBYTE ptmp = (PBYTE)pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<xDib;ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE blue  = (cx*2);
                        BYTE green = (cy*2);
                        BYTE red   = 255 - cx - cy;
                        *ptmp++ = gHalftoneColorXlate332[(red & 0xe0) | ((green & 0xe0) >> 3) | ((blue & 0xc0) >> 6)];
                    }
                }
            }
            else if (BitsPerPixel == 4)
            {
                PBYTE ptmp = (PBYTE)pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<(xDib/2);ux++)
                    {
                        BYTE cx   = (BYTE)ux & 0x7f;
                        BYTE cy   = (BYTE)uy & 0x7f;
                        BYTE Color = ((cx & 0x60) >> 3) | ((cy >> 5));

                        *ptmp++ = Color | (Color << 4);
                    }
                }
            }
            else if (BitsPerPixel == 1)
            {
                PBYTE ptmp = (PBYTE)pDib;

                for (uy=0;uy<yDib;uy++)
                {
                    for (ux=0;ux<(xDib/8);ux++)
                    {
                        *ptmp++ = 0;
                    }
                }
            }
        }

        //
        // draw text into bitmap
        //

        if (hdib)
        {

            ULONG             ux,uy;

            HDC hdcm  = CreateCompatibleDC(hdc);

            //
            // display over black
            //

            HPALETTE hpal = CreateHalftonePalette(hdc);

            SelectObject(hdcm,hdib);

            SelectPalette(hdcm,hpal,FALSE);

            RealizePalette(hdcm);

            SetTextColor(hdcm,RGB(255,255,255));
            SetBkMode(hdcm,TRANSPARENT);

            TextOut(hdcm,0,  0," 0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F",47);
            TextOut(hdcm,0, 10,"10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F",47);
            TextOut(hdcm,0, 20,"20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F",47);
            TextOut(hdcm,0, 30,"30 33 32 33 34 33 36 37 38 39 3A 3B 3C 3D 3E 3F",47);
            TextOut(hdcm,0, 40,"40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F",47);
            TextOut(hdcm,0, 50,"50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F",47);
            TextOut(hdcm,0, 60,"60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F",47);
            TextOut(hdcm,0, 70,"70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F",47);
            TextOut(hdcm,0, 80,"80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F",47);
            TextOut(hdcm,0, 90,"90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F",47);
            TextOut(hdcm,0,100,"a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 AA AB AC AD AE AF",47);
            TextOut(hdcm,0,110,"b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 BA BB BC BD BE BF",47);

            DeleteDC(hdcm);
            DeleteObject(hpal);
        }

        LocalFree(pbmi);
    }

    return(hdib);
}

/******************************Public*Routine******************************\
* vTestAlphaStretch - routine is called by format specific routines to do
* all drawing
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4-Jun-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vRunAlphaStretch(
    HDC     hdc,
    HBITMAP hdib
    )
{
    ULONG         xpos  = 10;
    ULONG         ypos  = 10;
    ULONG         dy    = 136;
    ULONG         dx    = 128+5;
    HPALETTE      hpal;
    HPALETTE      hpalOld;
    BLENDFUNCTION BlendFunction;
    BYTE          Alphas[] = {64,128,160,192,224,255};
    RECT          rect;
    PBITMAPINFO   pbmi;
    ULONG         ux,uy;
    PULONG        pDib;
    HDC           hdcm  = CreateCompatibleDC(hdc);

    //
    // Clear screen
    //

    SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
    PatBlt(hdc,0,0,2000,2000,PATCOPY);

    hpal = CreateHalftonePalette(hdc);

    SelectObject(hdcm,hdib);

    SelectPalette(hdcm,hpal,FALSE);

    RealizePalette(hdcm);

    SetTextColor(hdc,RGB(255,255,255));
    SetBkMode(hdc,TRANSPARENT);
    SelectObject(hdc,hbrFillCars);

    BlendFunction.BlendOp             = AC_SRC_OVER;
    BlendFunction.AlphaFormat         = 0;
    BlendFunction.SourceConstantAlpha = Alphas[3];

    xpos = 10;

    TextOut(hdc,xpos,ypos,"- - 128 128,   0   0 128,128",28);

    xpos += 250;

    TextOut(hdc,xpos,ypos,"- - 128 128,   0   0  64, 64",28);

    xpos += 250;

    TextOut(hdc,xpos,ypos,"- - 128 128,   0   0 256,256",28);

    xpos =  10;
    ypos += 12;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm, 0,0,128,128,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm, 0,0,64,64,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm, 0,0,256,256,BlendFunction);

    xpos += 250;
    BitBlt(hdc,xpos,ypos,128,128,hdcm,0,0,SRCCOPY);

    ypos += 180;
    xpos  = 10;

    TextOut(hdc,xpos,ypos,"- - 128 128, -64   0 128,128",28);
    xpos += 250;

    TextOut(hdc,xpos,ypos,"- - 128 128,   0 -64 128,128",28);
    xpos += 250;

    TextOut(hdc,xpos,ypos,"- - 128 128, -64 -64 128,128",28);

    ypos += 12;
    xpos = 10;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm,-64,0,128,128,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm,0,-64,128,128,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm, -64,-64,128,128,BlendFunction);

    xpos += 250;
    BitBlt(hdc,xpos,ypos,128,128,hdcm,0,0,SRCCOPY);

    ypos += 180;
    xpos  = 10;

    TextOut(hdc,xpos,ypos,"- - 128 128, -32 -32 192,192",28);
    xpos += 250;

    TextOut(hdc,xpos,ypos,"- - 128 128,   0 -32 128,192",28);
    xpos += 250;

    TextOut(hdc,xpos,ypos,"- - 128 128, -32   0 192,128",28);

    ypos += 12;
    xpos = 10;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm,-32,-32,192,192,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm,0,-32,128,192,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm, -32,0,192,128,BlendFunction);

    xpos += 250;
    BitBlt(hdc,xpos,ypos,128,128,hdcm,0,0,SRCCOPY);

    ypos += 180;
    xpos  = 10;

    TextOut(hdc,xpos,ypos,"- - 128 128, -32 -32 42,42",28);
    xpos += 250;

    TextOut(hdc,xpos,ypos,"128-10,128-10  10 10 41   5 ",28);
    xpos += 250;

    TextOut(hdc,xpos,ypos,"- - 128 128, -1000,-1000,100",28);

    ypos += 12;
    xpos = 10;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm,-32,-32,42,42,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos+128-10,ypos+128-10,10,10,hdcm,10,10,41,5,BlendFunction);

    xpos += 250;

    PatBlt(hdc,xpos,ypos,128,128,PATCOPY);
    AlphaBlend(hdc,xpos      ,ypos,128,128,hdcm, -1000,-10000,1000,1000,BlendFunction);

    xpos += 250;
    BitBlt(hdc,xpos,ypos,128,128,hdcm,0,0,SRCCOPY);

    //
    // free objects
    //

    DeleteDC(hdcm);
    DeleteObject(hpal);
}


/**************************************************************************\
* pbmiCreateAlphaStretchDIB - create bitmapinfo and alloc and init bits
*                             based on input
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/9/1997 Mark Enstrom [marke]
*
\**************************************************************************/

PBITMAPINFO
pbmiCreateAlphaStretchDIB(
    HDC      hdc,
    ULONG    BitsPerPixel,
    ULONG    ColorFormat,
    PVOID   *pBits,
    HBITMAP *phdib
    )
{
    PBITMAPINFO pbmi;
    BYTE        ux,uy;
    HBITMAP     hdib = NULL;
    LONG        Compression = BI_RGB;
    PULONG      pDib = NULL;
    LONG        BitmapSize = 0;
    ULONG       iUsage = DIB_RGB_COLORS;

    //
    // prepare src DC log colors
    //

    HPALETTE hpal = CreateHalftonePalette(hdc);
    HPALETTE hpalOld = SelectPalette(hdc,hpal,FALSE);
    RealizePalette(hdc);

    //
    // alloc pbmi, caller must free
    //

    pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));

    if (pbmi)
    {
        PULONG pulMask = (PULONG)&pbmi->bmiColors[0];


        //
        // prepare compression and color table
        //

        if ((BitsPerPixel == 32) && (!(ColorFormat & FORMAT_ALPHA)))
        {
            pulMask[0] = 0x0000ff;
            pulMask[1] = 0x00ff00;
            pulMask[2] = 0xff0000;
            Compression = BI_BITFIELDS;
        }
        else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_565))
        {
            pulMask[0] = 0xf800;
            pulMask[1] = 0x07e0;
            pulMask[2] = 0x001f;
            Compression = BI_BITFIELDS;
        }
        else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_555))
        {
            pulMask[0] = 0x7c00;
            pulMask[1] = 0x03e0;
            pulMask[2] = 0x001f;
            Compression = BI_BITFIELDS;
        }
        else if ((BitsPerPixel == 8) && (ColorFormat == DIB_RGB_COLORS))
        {
            ULONG ulIndex;

            for (ulIndex=0;ulIndex<256;ulIndex++)
            {
                pulMask[ulIndex] = htPaletteRGBQUAD[ulIndex];
            }
        }
        else if ((BitsPerPixel == 8) && (ColorFormat == DIB_PAL_COLORS))
        {
            ULONG ulIndex;
            PUSHORT pusIndex = (PUSHORT)pulMask;

            for (ulIndex=0;ulIndex<256;ulIndex++)
            {
                pusIndex[ulIndex] = (USHORT)ulIndex;
            }
            iUsage = DIB_PAL_COLORS;
        }
        else if ((BitsPerPixel == 4) && (ColorFormat == DIB_RGB_COLORS))
        {
            ULONG ulIndex;

            for (ulIndex=0;ulIndex<8;ulIndex++)
            {
                pulMask[ulIndex]    = DefPaletteRGBQUAD[ulIndex];
                pulMask[15-ulIndex] = DefPaletteRGBQUAD[20-ulIndex];
            }
            BitmapSize = (128 * 128)/2;
        }
        else if ((BitsPerPixel == 4) && (ColorFormat == DIB_PAL_COLORS))
        {
            ULONG ulIndex;
            PUSHORT pusIndex = (PUSHORT)pulMask;

            for (ulIndex=0;ulIndex<8;ulIndex++)
            {
                pusIndex[ulIndex] = (USHORT)ulIndex;
                pusIndex[15-ulIndex] = (USHORT)(255-ulIndex);
            }
            iUsage = DIB_PAL_COLORS;
        }
        else if ((BitsPerPixel == 1) && (ColorFormat == DIB_RGB_COLORS))
        {
            pulMask[0] = DefPaletteRGBQUAD[0];
            pulMask[1] = DefPalette[19];
            BitmapSize = (128 * 128)/8;
        }
        else if ((BitsPerPixel == 1) && (ColorFormat == DIB_PAL_COLORS))
        {
            ULONG ulIndex;
            PUSHORT pusIndex = (PUSHORT)pulMask;

            pusIndex[0] = 0;
            pusIndex[1] = 255;
            iUsage = DIB_PAL_COLORS;
        }

        //
        // init bitmap info
        //

        pbmi->bmiHeader.biSize            = sizeof(BITMAPINFOHEADER);
        pbmi->bmiHeader.biWidth           = 128;
        pbmi->bmiHeader.biHeight          = 128;
        pbmi->bmiHeader.biPlanes          = 1;
        pbmi->bmiHeader.biBitCount        = (USHORT)BitsPerPixel;
        pbmi->bmiHeader.biCompression     = Compression;
        pbmi->bmiHeader.biSizeImage       = 0;
        pbmi->bmiHeader.biXPelsPerMeter   = 0;
        pbmi->bmiHeader.biYPelsPerMeter   = 0;
        pbmi->bmiHeader.biClrUsed         = 0;
        pbmi->bmiHeader.biClrImportant    = 0;

        hdib  = CreateDIBSection(hdc,pbmi,iUsage,(VOID **)&pDib,NULL,0);

        if (hdib == NULL)
        {
            CHAR tmsg[256];

            //wsprintf(tmsg,"Format = %libpp, Comp = %li",BitsPerPixel,Compression);
            //MessageBox(NULL,"Can't create stretchDIB DIBSECTION",tmsg,MB_OK);
            //LocalFree(pbmi);
            //return(NULL);
        }
        else
        {
            //
            // init 32 bpp dib
            //

            if ((BitsPerPixel == 32) && (ColorFormat & FORMAT_ALPHA))
            {
                PULONG ptmp = pDib;

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<128;ux++)
                    {
                        BYTE blue  = (ux*2);
                        BYTE green = (uy*2);
                        BYTE red   = 255 - ux - uy;
                        BYTE alpha = 0xff;
                        *ptmp++ = (alpha << 24) | (red << 16) | (green << 8) | (blue);
                    }
                }
            }
            else if (BitsPerPixel == 32)
            {
                PULONG ptmp = pDib;

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<128;ux++)
                    {
                        BYTE blue  = (ux*2);
                        BYTE green = (uy*2);
                        BYTE red   = 255 - ux - uy;
                        *ptmp++ = (blue << 16) | (green << 8) | (red);
                    }
                }
            }
            else if (BitsPerPixel == 24)
            {
                PBYTE ptmp = (PBYTE)pDib;

                //
                // since scan line is 128, alignment works. If width changes, this breaks
                //

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<128;ux++)
                    {
                        BYTE blue  = (ux*2);
                        BYTE green = (uy*2);
                        BYTE red   = 255 - ux - uy;
                        *ptmp++ = (blue);
                        *ptmp++ = (green);
                        *ptmp++ = (red);
                    }
                }
            }
            else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_565))
            {
                PUSHORT ptmp = (PUSHORT)pDib;

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<128;ux++)
                    {
                        BYTE blue  = (ux*2);
                        BYTE green = (uy*2);
                        BYTE red   = 255 - ux - uy;
                        BYTE alpha = 0xff;
                        *ptmp++ = ((red & 0xf8)   << 8) |
                                  ((green & 0xfc) << 3) |
                                  (blue >> 3);
                    }
                }
            }
            else if ((BitsPerPixel == 16) && (ColorFormat & FORMAT_16_555))
            {
                PUSHORT ptmp = (PUSHORT)pDib;

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<128;ux++)
                    {
                        BYTE blue  = (ux*2);
                        BYTE green = (uy*2);
                        BYTE red   = 255 - ux - uy;
                        BYTE alpha = 0xff;
                        *ptmp++ = ((red & 0xf8)   << 7) |
                                  ((green & 0xf8) << 2) |
                                  (blue >> 3);
                    }
                }
            }
            else if (BitsPerPixel == 8)
            {
                PBYTE ptmp = (PBYTE)pDib;

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<128;ux++)
                    {
                        BYTE blue  = (ux*2);
                        BYTE green = (uy*2);
                        BYTE red   = 255 - ux - uy;
                        *ptmp++ = gHalftoneColorXlate332[(red & 0xe0) | ((green & 0xe0) >> 3) | ((blue & 0xc0) >> 6)];
                    }
                }
            }
            else if (BitsPerPixel == 4)
            {
                PBYTE ptmp = (PBYTE)pDib;

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<(128/2);ux++)
                    {
                        BYTE Color = ((ux & 0x60) >> 3) | ((uy >> 5));

                        *ptmp++ = Color | (Color << 4);
                    }
                }
            }
            else if (BitsPerPixel == 1)
            {
                PBYTE ptmp = (PBYTE)pDib;

                for (uy=0;uy<128;uy++)
                {
                    for (ux=0;ux<(128/8);ux++)
                    {
                        *ptmp++ = 0;
                    }
                }
            }
        }
    }

    //
    //  create a test memory DC
    //

    if (hdib)
    {
        //
        // write text into DIB
        //

        HDC hdcm  = CreateCompatibleDC(hdc);

        //
        // display over black
        //

        SelectObject(hdcm,hdib);
        SelectPalette(hdcm,hpal,FALSE);
        RealizePalette(hdcm);

        SetTextColor(hdcm,RGB(255,255,255));
        SetBkMode(hdcm,TRANSPARENT);

        TextOut(hdcm,0,  0," 0  1  2  3  4  5  6  7  8  9 ",30);
        TextOut(hdcm,0, 10,"10 11 12 13 14 15 16 17 18 19 ",30);
        TextOut(hdcm,0, 20,"20 21 22 23 24 25 26 27 28 29 ",30);
        TextOut(hdcm,0, 30,"30 33 32 33 34 33 36 37 38 39 ",30);
        TextOut(hdcm,0, 40,"40 41 42 43 44 45 46 47 48 49 ",30);
        TextOut(hdcm,0, 50,"50 51 52 53 54 55 56 57 58 59 ",30);
        TextOut(hdcm,0, 60,"60 61 62 63 64 65 66 67 68 69 ",30);
        TextOut(hdcm,0, 70,"70 71 72 73 74 75 76 77 78 79 ",30);
        TextOut(hdcm,0, 80,"80 81 82 83 84 85 86 87 88 89 ",30);
        TextOut(hdcm,0, 90,"90 91 92 93 94 95 96 97 98 99 ",30);
        TextOut(hdcm,0,100,"a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 ",30);
        TextOut(hdcm,0,110,"b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ",30);

        DeleteDC(hdcm);
    }

    SelectPalette(hdc,hpalOld,TRUE);
    DeleteObject(hpal);

    *pBits = (PVOID)pDib;
    *phdib = hdib;

    if (hdib == NULL)
    {
        LocalFree(pbmi);
        pbmi = NULL;
    }

    return(pbmi);
}

/******************************Public*Routine******************************\
* vTestAlphaStretch - routine is called by format specific routines to do
* all drawing
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4-Jun-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vRunAlphaStretchDIB(
    HDC         hdc,
    PBITMAPINFO pbmi,
    PVOID       pBits,
    ULONG       iUsage
    )
{
    ULONG         xpos  = 10;
    ULONG         ypos  = 10;
    ULONG         dy    = 136;
    ULONG         dx    = 128+5;
    HPALETTE      hpal;
    HPALETTE      hpalOld;
    BLENDFUNCTION BlendFunction;
    BYTE          Alphas[] = {64,128,160,192,224,255};
    RECT          rect;

    if ((iUsage != DIB_RGB_COLORS) && (iUsage != DIB_PAL_COLORS))
    {
        iUsage = DIB_RGB_COLORS;
    }

    //
    // Clear screen
    //

    SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
    PatBlt(hdc,0,0,2000,2000,PATCOPY);

    {
        ULONG             ux,uy;

        SetTextColor(hdc,RGB(255,255,255));
        SetBkMode(hdc,TRANSPARENT);
        SelectObject(hdc,hbrFillCars);

        BlendFunction.BlendOp             = AC_SRC_OVER;
        BlendFunction.AlphaFormat         = 0;
        BlendFunction.SourceConstantAlpha = Alphas[2];

        xpos = 10;

        TextOut(hdc,xpos,ypos,"- - 128 128,   0   0 128,128",28);

        xpos += 250;

        TextOut(hdc,xpos,ypos,"- - 128 128,   0   0  64, 64",28);

        xpos += 250;

        TextOut(hdc,xpos,ypos,"- - 128 128,   0   0 256,256",28);

        xpos =  10;
        ypos += 12;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;
        SetDIBitsToDevice(hdc,xpos,ypos,128,128,0,0,0,128,pBits,pbmi,iUsage);

        ypos += 180;
        xpos  = 10;

        TextOut(hdc,xpos,ypos,"- - 128 128, -64   0 128,128",28);
        xpos += 250;

        TextOut(hdc,xpos,ypos,"- - 128 128,   0 -64 128,128",28);
        xpos += 250;

        TextOut(hdc,xpos,ypos,"- - 128 128, -64 -64 128,128",28);

        ypos += 12;
        xpos = 10;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;
        SetDIBitsToDevice(hdc,xpos,ypos,128,128,0,0,0,128,pBits,pbmi,iUsage);

        ypos += 180;
        xpos  = 10;

        TextOut(hdc,xpos,ypos,"- - 128 128, -32 -32 192,192",28);
        xpos += 250;

        TextOut(hdc,xpos,ypos,"- - 128 128,   0 -32 128,192",28);
        xpos += 250;

        TextOut(hdc,xpos,ypos,"- - 128 128, -32   0 192,128",28);

        ypos += 12;
        xpos = 10;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;
        SetDIBitsToDevice(hdc,xpos,ypos,128,128,0,0,0,128,pBits,pbmi,iUsage);

        ypos += 180;
        xpos  = 10;

        TextOut(hdc,xpos,ypos,"- - 128 128, -32 -32 42,42",28);
        xpos += 250;

        TextOut(hdc,xpos,ypos,"128-10,128-10  10 10 41   5 ",28);
        xpos += 250;

        TextOut(hdc,xpos,ypos,"- - 128 128, -1000,-1000,100",28);

        ypos += 12;
        xpos = 10;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;

        PatBlt(hdc,xpos,ypos,128,128,PATCOPY);

        xpos += 250;
        SetDIBitsToDevice(hdc,xpos,ypos,128,128,0,0,0,128,pBits,pbmi,iUsage);
    }
}


/**************************************************************************\
* vTestAlphaStretch
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vTestAlphaStretch(
    HWND  hwnd,
    HDC   hdc,
    RECT* prcl
    )
{
    HDC      hdcm = CreateCompatibleDC(hdc);
    HPALETTE hpal = CreateHalftonePalette(hdc);
    HPALETTE hpalOld;
    CHAR     Title[256];
    CHAR     NewTitle[256];
    ULONG    ulIndex = 0;

    GetWindowText(hwnd,Title,256);

    lstrcpy(NewTitle,Title);
    lstrcat(NewTitle,pFormatStr[ulIndex]);
    SetWindowText(hwnd,NewTitle);

    //
    // repeat for each src format
    //


    hpalOld = SelectPalette(hdc,hpal,FALSE);
    RealizePalette(hdc);

    while (ulBpp[ulIndex] != 0)
    {
        HBITMAP  hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],128,128);

        if (hdib != NULL)
        {
            lstrcpy(NewTitle,Title);
            lstrcat(NewTitle,pFormatStr[ulIndex]);
            SetWindowText(hwnd,NewTitle);

            vRunAlphaStretch(hdc,hdib);
            DeleteObject(hdib);
        }

        Sleep(gAlphaSleep);
        ulIndex++;
    }

    SetWindowText(hwnd,Title);
    SelectPalette(hdc,hpalOld,TRUE);
    DeleteDC(hdcm);
    DeleteObject(hpal);
}

/**************************************************************************\
* vTestAlphaStretchDIB
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vTestAlphaStretchDIB(
     HWND  hwnd,
     HDC   hdc,
     RECT* prcl
    )
{
    HDC      hdcm = CreateCompatibleDC(hdc);
    HPALETTE hpal = CreateHalftonePalette(hdc);
    HPALETTE hpalOld;
    CHAR     Title[256];
    CHAR     NewTitle[256];
    ULONG    ulIndex = 0;

    GetWindowText(hwnd,Title,256);

    hpalOld = SelectPalette(hdc,hpal,FALSE);
    RealizePalette(hdc);

    while (ulBppDIB[ulIndex] != 0)
    {
       PVOID       pBits = NULL;
       PBITMAPINFO pbmi  = NULL;
       HBITMAP     hdib  = NULL;

        pbmi = pbmiCreateAlphaStretchDIB(hdc,ulBppDIB[ulIndex],ulForDIB[ulIndex],&pBits,&hdib);

        if (hdib != NULL)
        {
            lstrcpy(NewTitle,Title);
            lstrcat(NewTitle,pFormatStrDIB[ulIndex]);
            SetWindowText(hwnd,NewTitle);

            vRunAlphaStretchDIB(hdc,pbmi,pBits,ulForDIB[ulIndex]);
            DeleteObject(hdib);
        }

        Sleep(gAlphaSleep);
        ulIndex++;
    }

    SetWindowText(hwnd,Title);
    SelectPalette(hdc,hpalOld,TRUE);
    DeleteDC(hdcm);
    DeleteObject(hpal);
}


/**************************************************************************\
* vRunGradHorz
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/17/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vRunGradRectHorz(
    HDC     hdc,
    HBITMAP hdib,
    ULONG   ulRectMode
    )
{
    ULONG         xpos  = 10;
    ULONG         ypos  = 10;
    ULONG         dy    = 10;
    ULONG         dx    = 10;
    HPALETTE      hpal;
    HPALETTE      hpalOld;
    RECT          rect;

    //
    //  create mem dc, select test DIBSection
    //

    ULONG   ux,uy;
    ULONG   dibx,diby;
    PULONG  pDib;

    HDC hdcm  = CreateCompatibleDC(hdc);

    GRADIENT_RECT gRect = {0,1};
    TRIVERTEX vert[6];
    HBRUSH hbrCyan = CreateSolidBrush(RGB(0,255,255));
    USHORT OffsetX = 0;
    USHORT OffsetY = 0;
    HRGN hrgn1 = CreateEllipticRgn(10,10,246,246);

    //
    // Clear screen
    //

    SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
    PatBlt(hdc,0,0,2000,2000,PATCOPY);

    //
    // display over black
    //

    hpal = CreateHalftonePalette(hdc);

    SelectObject(hdcm,hdib);
    SelectObject(hdcm,GetStockObject(DKGRAY_BRUSH));
    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    hpalOld = SelectPalette(hdc,hpal,FALSE);
    SelectPalette(hdcm,hpal,FALSE);

    RealizePalette(hdc);
    RealizePalette(hdcm);

    SetTextColor(hdc,RGB(255,255,255));
    SetBkMode(hdc,TRANSPARENT);


    //
    // fill screen background
    //

    vert[0].x     = -101;
    vert[0].y     = -102;
    vert[0].Red   = 0x4000;
    vert[0].Green = 0x0000;
    vert[0].Blue  = 0x8000;
    vert[0].Alpha = 0x0000;

    vert[1].x     = 2000;
    vert[1].y     = 3004;
    vert[1].Red   = 0xff00;
    vert[1].Green = 0x0000;
    vert[1].Blue  = 0xff00;
    vert[1].Alpha = 0x0000;

    GradientFill(hdc,vert,2,(PVOID)&gRect,1,ulRectMode);

    //
    // test widths and heights
    //

    diby = 16;

    for (uy=0;uy<16;uy++)
    {
        dibx = 16;

        for (ux=1;ux<17;ux++)
        {
            vert[0].x     = dibx;
            vert[0].y     = diby;
            vert[0].Red   = 0x0000;
            vert[0].Green = 0x0000;
            vert[0].Blue  = 0x0000;
            vert[0].Alpha = 0x0000;

            vert[1].x     = dibx + ux;
            vert[1].y     = diby + ux;
            vert[1].Red   = 0xff00;
            vert[1].Green = 0x0000;
            vert[1].Blue  = 0xff00;
            vert[1].Alpha = 0x0000;

            GradientFill(hdcm,vert,2,(PVOID)&gRect,1,ulRectMode);

            dibx = dibx + 17;
        }

        diby += 20;
    }

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);
    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    //
    // test Solid Widths and heights
    //

    xpos = xpos + (256 + 16);

    diby = 16;

    for (uy=1;uy<16;uy++)
    {
        dibx = 16;

        for (ux=1;ux<17;ux++)
        {
            vert[0].x     = dibx;
            vert[0].y     = diby;
            vert[0].Red   = 0x0000;
            vert[0].Green = 0xff00;
            vert[0].Blue  = 0xff00;
            vert[0].Alpha = 0x0000;

            vert[1].x     = dibx + uy;
            vert[1].y     = diby + uy;
            vert[1].Red   = 0x0000;
            vert[1].Green = 0xff00;
            vert[1].Blue  = 0xff00;
            vert[1].Alpha = 0x0000;

            GradientFill(hdcm,vert,2,(PVOID)&gRect,1,ulRectMode);

            dibx = dibx + 17;
        }

        diby += 20;
    }

    //
    // display
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // xor copy
    //

    xpos += (256+16);

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // Draw same thing with solid brush and xor
    //

    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    SelectObject(hdcm,hbrCyan);

    diby = 16;

    for (uy=1;uy<16;uy++)
    {
        dibx = 16;

        for (ux=1;ux<17;ux++)
        {
            PatBlt(hdcm,dibx,diby,uy,uy,PATCOPY);

            dibx = dibx + 17;
        }

        diby += 20;
    }

    SelectObject(hdcm,GetStockObject(DKGRAY_BRUSH));
    DeleteObject(hbrCyan);

    //
    // display
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // XOR
    //

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,0x660000);


    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    xpos = 16;
    ypos += (16+256);

    //
    // draw a single rectangle, then draw same rectangle by drawing
    // smaller rectangles inside each other. XOR to compare
    //
    //
    //
    //
    //

    vert[0].x     = 0;
    vert[0].y     = 0;
    vert[0].Red   = 0x8000;
    vert[0].Green = 0x0000;
    vert[0].Blue  = 0x0000;
    vert[0].Alpha = 0x0000;

    vert[1].x     = 256;
    vert[1].y     = 256;
    vert[1].Red   = 0x8000;
    vert[1].Green = 0x8000;
    vert[1].Blue  = 0x8000;
    vert[1].Alpha = 0x0000;

    GradientFill(hdcm,vert,2,(PVOID)&gRect,1,ulRectMode);

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // draw rectangles inside rectangles to test dither org
    //


    //
    // range in x = 256, range in color = 0xfe00 (256 * 128)
    //

    while (OffsetX < 128)
    {
        vert[0].x     = OffsetX;
        vert[0].y     = OffsetY;
        vert[0].Red   = 0x8000;
        vert[0].Green = 0x0000 + (128 * OffsetX);
        vert[0].Blue  = 0x0000 + (128 * OffsetX);
        vert[0].Alpha = 0x0000;

        vert[1].x     = 256-OffsetX;
        vert[1].y     = 256-OffsetY;
        vert[1].Red   = 0x8000;
        vert[1].Green = 0x8000 - (128 * OffsetX);
        vert[1].Blue  = 0x8000 - (128 * OffsetX);
        vert[1].Alpha = 0x0000;

        GradientFill(hdcm,vert,2,(PVOID)&gRect,1,ulRectMode);

        OffsetX += 9;
        OffsetY += 9;
    }

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,0x660000);

    xpos = 16;
    ypos += (16+256);

    //
    // draw a single rectangle, then draw same rectangle by drawing
    // smaller rectangles inside each other. XOR to compare
    //
    //
    // Use Complex Clip
    //
    //

    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    ExtSelectClipRgn(hdcm,hrgn1,RGN_COPY);

    vert[0].x     = 0;
    vert[0].y     = 0;
    vert[0].Red   = 0x8000;
    vert[0].Green = 0x0000;
    vert[0].Blue  = 0x0000;
    vert[0].Alpha = 0x0000;

    vert[1].x     = 256;
    vert[1].y     = 256;
    vert[1].Red   = 0x8000;
    vert[1].Green = 0x8000;
    vert[1].Blue  = 0x8000;
    vert[1].Alpha = 0x0000;

    GradientFill(hdcm,vert,2,(PVOID)&gRect,1,ulRectMode);

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // draw rectangles inside rectangles to test dither org
    //

    OffsetX = 0;
    OffsetY = 0;

    //
    // range in x = 256, range in color = 0xfe00 (256 * 128)
    //

    while (OffsetX < 128)
    {
        vert[0].x     = OffsetX;
        vert[0].y     = OffsetY;
        vert[0].Red   = 0x8000;
        vert[0].Green = 0x0000 + (128 * OffsetX);
        vert[0].Blue  = 0x0000 + (128 * OffsetX);
        vert[0].Alpha = 0x0000;

        vert[1].x     = 256-OffsetX;
        vert[1].y     = 256-OffsetY;
        vert[1].Red   = 0x8000;
        vert[1].Green = 0x8000 - (128 * OffsetX);
        vert[1].Blue  = 0x8000 - (128 * OffsetX);
        vert[1].Alpha = 0x0000;

        GradientFill(hdcm,vert,2,(PVOID)&gRect,1,ulRectMode);

        OffsetX += 9;
        OffsetY += 9;
    }

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,0x660000);

    ExtSelectClipRgn(hdcm,NULL,RGN_COPY);
    DeleteObject(hrgn1);

    xpos = 16;
    ypos += (256+16);

    SelectPalette(hdc,hpalOld,TRUE);

    DeleteObject(hdcm);
    DeleteObject(hpal);
}

/**************************************************************************\
* vTestGradHorz
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vTestGradRectHorz(
    HWND  hwnd,
    HDC   hdc,
    RECT* prcl
    )
{
    HPALETTE hpal = CreateHalftonePalette(hdc);
    HPALETTE hpalOld;
    CHAR     Title[256];
    CHAR     NewTitle[256];

    //
    // repeat for each src format
    //

    ULONG    ulIndex = 0;

    hpalOld = SelectPalette(hdc,hpal,FALSE);
    RealizePalette(hdc);

    while (ulBpp[ulIndex] != 0)
    {
        HBITMAP  hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],256,256);

        if (hdib != NULL)
        {
            lstrcpy(NewTitle,Title);
            lstrcat(NewTitle,pFormatStr[ulIndex]);

            vRunGradRectHorz(hdc,hdib,GRADIENT_FILL_RECT_H);
            DeleteObject(hdib);
        }

        Sleep(gAlphaSleep);
        ulIndex++;
    }

    SelectPalette(hdc,hpalOld,TRUE);
    DeleteObject(hpal);
}

/**************************************************************************\
* vTestGradVert
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vTestGradRectVert(
    HWND  hwnd,
    HDC   hdc,
    RECT* prcl
    )
{
    HPALETTE hpal = CreateHalftonePalette(hdc);
    HPALETTE hpalOld;
    CHAR     Title[256];
    CHAR     NewTitle[256];

    ULONG    ulIndex = 0;

    hpalOld = SelectPalette(hdc,hpal,FALSE);
    RealizePalette(hdc);

    //
    // repeat for each src format
    //

    while (ulBpp[ulIndex] != 0)
    {
        HBITMAP  hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],256,256);

        if (hdib != NULL)
        {
            lstrcpy(NewTitle,Title);
            lstrcat(NewTitle,pFormatStr[ulIndex]);

            vRunGradRectHorz(hdc,hdib,GRADIENT_FILL_RECT_V);
            DeleteObject(hdib);
        }

        Sleep(gAlphaSleep);
        ulIndex++;
    }

    SelectPalette(hdc,hpalOld,TRUE);
    DeleteObject(hpal);
}

/**************************************************************************\
* vRunGradTriangle
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/17/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vRunGradTriangle(
    HDC     hdc,
    HBITMAP hdib
    )
{
    ULONG         xpos  = 10;
    HBRUSH        hbrCyan = CreateSolidBrush(RGB(0,255,255));
    ULONG         ypos  = 10;
    ULONG         dy    = 10;
    ULONG         dx    = 10;
    HPALETTE      hpal;
    HPALETTE      hpalOld;
    RECT          rect;
    HRGN          hrgn1 = CreateEllipticRgn(10,10,246,246);
    ULONG         ux,uy;
    ULONG         dibx,diby;
    PULONG        pDib;
    TRIVERTEX     vert[6];
    USHORT        OffsetX = 0;
    USHORT        OffsetY = 0;
    HDC           hdcm  = CreateCompatibleDC(hdc);

    GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};

    //
    // Clear screen
    //

    SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
    PatBlt(hdc,0,0,2000,2000,PATCOPY);

    //
    // display over black
    //

    hpal = CreateHalftonePalette(hdc);

    SelectObject(hdcm,hdib);
    SelectObject(hdcm,GetStockObject(DKGRAY_BRUSH));
    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    hpalOld = SelectPalette(hdc,hpal,FALSE);
    SelectPalette(hdcm,hpal,FALSE);

    RealizePalette(hdc);
    RealizePalette(hdcm);

    SetTextColor(hdc,RGB(255,255,255));
    SetBkMode(hdc,TRANSPARENT);

    //
    // fill screen background
    //

    vert[0].x     = -101;
    vert[0].y     = -102;
    vert[0].Red   = 0x4000;
    vert[0].Green = 0x0000;
    vert[0].Blue  = 0x8000;
    vert[0].Alpha = 0x0000;

    vert[1].x     = 2000;
    vert[1].y     = -102;
    vert[1].Red   = 0x4400;
    vert[1].Green = 0x4400;
    vert[1].Blue  = 0xff00;
    vert[1].Alpha = 0x0000;

    vert[2].x     = 2000;
    vert[2].y     = 1000;
    vert[2].Red   = 0xff00;
    vert[2].Green = 0x0000;
    vert[2].Blue  = 0xff00;
    vert[2].Alpha = 0x0000;

    vert[3].x     = -101;
    vert[3].y     = 1000;
    vert[3].Red   = 0x0000;
    vert[3].Green = 0x4300;
    vert[3].Blue  = 0x0000;
    vert[3].Alpha = 0x0000;

    GradientFill(hdc,vert,4,(PVOID)&gTri,2,GRADIENT_FILL_TRIANGLE);

    //
    // test widths and heights
    //

    diby = 16;

    for (uy=0;uy<16;uy++)
    {
        dibx = 16;

        for (ux=1;ux<17;ux++)
        {
            vert[0].x     = dibx;
            vert[0].y     = diby;
            vert[0].Red   = 0x0000;
            vert[0].Green = 0x0000;
            vert[0].Blue  = 0x0000;
            vert[0].Alpha = 0x0000;

            vert[1].x     = dibx + ux;
            vert[1].y     = diby;
            vert[1].Red   = 0xff00;
            vert[1].Green = 0x0000;
            vert[1].Blue  = 0x0000;
            vert[1].Alpha = 0x0000;

            vert[2].x     = dibx + ux;
            vert[2].y     = diby + ux;
            vert[2].Red   = 0xff00;
            vert[2].Green = 0x0000;
            vert[2].Blue  = 0xff00;
            vert[2].Alpha = 0x0000;

            vert[3].x     = dibx;
            vert[3].y     = diby + ux;
            vert[3].Red   = 0x0000;
            vert[3].Green = 0x0000;
            vert[3].Blue  = 0xff00;
            vert[3].Alpha = 0x0000;

            GradientFill(hdcm,vert,4,(PVOID)&gTri,2,GRADIENT_FILL_TRIANGLE);

            dibx = dibx + 17;
        }

        diby += 20;
    }

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);
    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    //
    // test Solid Widths and heights
    //

    xpos = xpos + (256 + 16);

    diby = 16;

    for (uy=1;uy<16;uy++)
    {
        dibx = 16;

        for (ux=1;ux<17;ux++)
        {
            vert[0].x     = dibx;
            vert[0].y     = diby;
            vert[0].Red   = 0x0000;
            vert[0].Green = 0xff00;
            vert[0].Blue  = 0xff00;
            vert[0].Alpha = 0x0000;

            vert[1].x     = dibx + uy;
            vert[1].y     = diby;
            vert[1].Red   = 0x0000;
            vert[1].Green = 0xff00;
            vert[1].Blue  = 0xff00;
            vert[1].Alpha = 0x0000;

            vert[2].x     = dibx + uy;
            vert[2].y     = diby + uy;
            vert[2].Red   = 0x0000;
            vert[2].Green = 0xff00;
            vert[2].Blue  = 0xff00;
            vert[2].Alpha = 0x0000;

            vert[3].x     = dibx;
            vert[3].y     = diby + uy;
            vert[3].Red   = 0x0000;
            vert[3].Green = 0xff00;
            vert[3].Blue  = 0xff00;
            vert[3].Alpha = 0x0000;

            GradientFill(hdcm,vert,4,(PVOID)&gTri,2,GRADIENT_FILL_TRIANGLE);

            dibx = dibx + 17;
        }

        diby += 20;
    }

    //
    // display
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // xor copy
    //

    xpos += (256+16);

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // Draw same thing with solid brush and xor
    //

    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    SelectObject(hdcm,hbrCyan);

    diby = 16;

    for (uy=1;uy<16;uy++)
    {
        dibx = 16;

        for (ux=1;ux<17;ux++)
        {
            PatBlt(hdcm,dibx,diby,uy,uy,PATCOPY);

            dibx = dibx + 17;
        }

        diby += 20;
    }

    SelectObject(hdcm,GetStockObject(DKGRAY_BRUSH));
    DeleteObject(hbrCyan);

    //
    // display
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // XOR
    //

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,0x660000);


    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    xpos = 16;
    ypos += (16+256);

    //
    // draw a single rectangle, then draw same rectangle by drawing
    // smaller rectangles inside each other. XOR to compare
    //
    //
    //
    //
    //

    vert[0].x     = 0;
    vert[0].y     = 0;
    vert[0].Red   = 0x0000;
    vert[0].Green = 0x0000;
    vert[0].Blue  = 0x0000;
    vert[0].Alpha = 0x0000;

    vert[1].x     = 256;
    vert[1].y     = 0;
    vert[1].Red   = 0x0000;
    vert[1].Green = 0x0000;
    vert[1].Blue  = 0x0000;
    vert[1].Alpha = 0x0000;

    vert[2].x     = 256;
    vert[2].y     = 256;
    vert[2].Red   = 0xfe00;
    vert[2].Green = 0xfe00;
    vert[2].Blue  = 0xfe00;
    vert[2].Alpha = 0x0000;

    vert[3].x     = 0;
    vert[3].y     = 256;
    vert[3].Red   = 0xfe00;
    vert[3].Green = 0xfe00;
    vert[3].Blue  = 0xfe00;
    vert[3].Alpha = 0x0000;

    GradientFill(hdcm,vert,4,(PVOID)&gTri,2,GRADIENT_FILL_TRIANGLE);

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // draw rectangles inside rectangles to test dither org
    //
    // range in x = 256, range in color = 0xfe00 (256 * 128)
    //

    while ((OffsetX < 100) && (OffsetY < 100))
    {
        vert[0].x     = OffsetX;
        vert[0].y     = OffsetY;
        vert[0].Red   = 0x0000 + (254 * OffsetY);
        vert[0].Green = 0x0000 + (254 * OffsetY);
        vert[0].Blue  = 0x0000 + (254 * OffsetY);
        vert[0].Alpha = 0x0000;

        vert[1].x     = 256-OffsetX;
        vert[1].y     = OffsetY;
        vert[1].Red   = 0x0000 + (254 * OffsetY);
        vert[1].Green = 0x0000 + (254 * OffsetY);
        vert[1].Blue  = 0x0000 + (254 * OffsetY);
        vert[1].Alpha = 0x0000;

        vert[2].x     = 256-OffsetX;
        vert[2].y     = 256-OffsetY;
        vert[2].Red   = 0xfe00 - (254 * OffsetY);
        vert[2].Green = 0xfe00 - (254 * OffsetY);
        vert[2].Blue  = 0xfe00 - (254 * OffsetY);
        vert[2].Alpha = 0x0000;

        vert[3].x     = OffsetX;
        vert[3].y     = 256-OffsetY;
        vert[3].Red   = 0xfe00 - (254 * OffsetY);
        vert[3].Green = 0xfe00 - (254 * OffsetY);
        vert[3].Blue  = 0xfe00 - (254 * OffsetY);
        vert[3].Alpha = 0x0000;

        GradientFill(hdcm,vert,4,(PVOID)&gTri,2,GRADIENT_FILL_TRIANGLE);


        OffsetX += 9;
        OffsetY += 9;
    }

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,0x660000);

    xpos = 16;
    ypos += (16+256);

    //
    // draw a single rectangle, then draw same rectangle by drawing
    // smaller rectangles inside each other. XOR to compare
    //
    //
    // Use Complex Clip
    //
    //

    PatBlt(hdcm,0,0,2000,2000,PATCOPY);

    ExtSelectClipRgn(hdcm,hrgn1,RGN_COPY);

    vert[0].x     = 0;
    vert[0].y     = 0;
    vert[0].Red   = 0x0000;
    vert[0].Green = 0x0000;
    vert[0].Blue  = 0x0000;
    vert[0].Alpha = 0x0000;

    vert[1].x     = 256;
    vert[1].y     = 0;
    vert[1].Red   = 0x0000;
    vert[1].Green = 0x0000;
    vert[1].Blue  = 0x0000;
    vert[1].Alpha = 0x0000;

    vert[2].x     = 256;
    vert[2].y     = 256;
    vert[2].Red   = 0xfe00;
    vert[2].Green = 0xfe00;
    vert[2].Blue  = 0xfe00;
    vert[2].Alpha = 0x0000;

    vert[3].x     = 0;
    vert[3].y     = 256;
    vert[3].Red   = 0xfe00;
    vert[3].Green = 0xfe00;
    vert[3].Blue  = 0xfe00;
    vert[3].Alpha = 0x0000;

    GradientFill(hdcm,vert,4,(PVOID)&gTri,2,GRADIENT_FILL_TRIANGLE);

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos+256+16,ypos,256,256,hdcm,0,0,SRCCOPY);

    //
    // draw rectangles inside rectangles to test dither org
    //

    OffsetX = 0;
    OffsetY = 0;

    //
    // range in x = 256, range in color = 0xfe00 (256 * 128)
    //

    while ((OffsetX < 100) && (OffsetY < 100))
    {
        vert[0].x     = OffsetX;
        vert[0].y     = OffsetY;
        vert[0].Red   = 0x0000 + (254 * OffsetY);
        vert[0].Green = 0x0000 + (254 * OffsetY);
        vert[0].Blue  = 0x0000 + (254 * OffsetY);
        vert[0].Alpha = 0x0000;

        vert[1].x     = 256-OffsetX;
        vert[1].y     = OffsetY;
        vert[1].Red   = 0x0000 + (254 * OffsetY);
        vert[1].Green = 0x0000 + (254 * OffsetY);
        vert[1].Blue  = 0x0000 + (254 * OffsetY);
        vert[1].Alpha = 0x0000;

        vert[2].x     = 256-OffsetX;
        vert[2].y     = 256-OffsetY;
        vert[2].Red   = 0xfe00 - (254 * OffsetY);
        vert[2].Green = 0xfe00 - (254 * OffsetY);
        vert[2].Blue  = 0xfe00 - (254 * OffsetY);
        vert[2].Alpha = 0x0000;

        vert[3].x     = OffsetX;
        vert[3].y     = 256-OffsetY;
        vert[3].Red   = 0xfe00 - (254 * OffsetY);
        vert[3].Green = 0xfe00 - (254 * OffsetY);
        vert[3].Blue  = 0xfe00 - (254 * OffsetY);
        vert[3].Alpha = 0x0000;

        GradientFill(hdcm,vert,4,(PVOID)&gTri,2,GRADIENT_FILL_TRIANGLE);

        OffsetX += 9;
        OffsetY += 9;
    }

    //
    // display copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,SRCCOPY);

    xpos += (256+16);

    //
    // xor copy
    //

    BitBlt(hdc,xpos,ypos,256,256,hdcm,0,0,0x660000);

    ExtSelectClipRgn(hdcm,NULL,RGN_COPY);

    xpos = 16;
    ypos += (256+16);

    SelectPalette(hdc,hpalOld,TRUE);

    DeleteObject(hdcm);
    DeleteObject(hpal);
    DeleteObject(hrgn1);
    DeleteObject(hbrCyan);
}

/**************************************************************************\
* vTestTriangle
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vTestGradTriangle(
    HWND  hwnd,
    HDC   hdc,
    RECT* prcl
    )
{
    HPALETTE hpal = CreateHalftonePalette(hdc);
    HPALETTE hpalOld = NULL;

    CHAR     Title[256];
    CHAR     NewTitle[256];

    ULONG    ulIndex = 0;

    hpalOld = SelectPalette(hdc,hpal,FALSE);
    RealizePalette(hdc);

    while (ulBpp[ulIndex] != 0)
    {
        HBITMAP  hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],256,256);

        if (hdib != NULL)
        {
            vRunGradTriangle(hdc,hdib);
            DeleteObject(hdib);
        }

        Sleep(gAlphaSleep);
        ulIndex++;
    }

    SelectPalette(hdc,hpalOld,TRUE);
    DeleteObject(hpal);
}

/**************************************************************************\
* vTestGradFill
* vTestAlphaBlend
*
*   run tests
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
*    4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/

VOID
vTestGradFill(
    HWND  hwnd,
    HDC   hdc,
    RECT* prcl
    )
{
    vTestGradTriangle(hwnd,hdc,prcl);
    //vTestGradRectVert(hwnd,hdc,prcl);
    //vTestGradRectHorz(hwnd,hdc,prcl);
}

VOID
vTestAlphaBlend(
    HWND  hwnd,
    HDC   hdc,
    RECT* prcl
    )
{
    vTestAlphaStretch(hwnd,hdc,prcl);
    vTestAlphaStretchDIB(hwnd,hdc,prcl);
}