/*++
Copyright (c) 1996 Microsoft Corporation
Module Name
test.c
Abstract:
Small, independent windows test programs
Author:
Mark Enstrom (marke) 29-Apr-1996
Enviornment:
User Mode
Revision History:
--*/
#include "precomp.h"
#include <stdlib.h>
#include "disp.h"
#include "resource.h"
extern ULONG gAlphaSleep;
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTri(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE Tri[10];
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
HDC hdcmA = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
HBITMAP hdib;
HBITMAP hdibA;
PBYTE pDib;
PBYTE pDibA;
BLENDFUNCTION BlendFunction;
LONG xpos = 10;
LONG ypos = 10;
LONG xposDib = 0;
LONG yposDib = 0;
//
// tile screen
//
{
RECT rect;
HBITMAP hbmCars = LoadBitmap(hInstMain,MAKEINTRESOURCE(CAR_BITMAP));
LOGBRUSH lgBrush;
HBRUSH hbrFill;
lgBrush.lbStyle = BS_PATTERN;
lgBrush.lbColor = 0;
lgBrush.lbHatch = (LONG)hbmCars;
hbrFill = CreateBrushIndirect(&lgBrush);
GetClientRect(pCallData->hwnd,&rect);
FillTransformedRect(hdc,&rect,hbrFill);
DeleteObject(hbrFill);
DeleteObject(hbmCars);
}
//
// init drawing modes
//
SetStretchBltMode(hdc,COLORONCOLOR);
BlendFunction.BlendOp = AC_SRC_OVER;
BlendFunction.BlendFlags = 0;
BlendFunction.SourceConstantAlpha = 255;
BlendFunction.AlphaFormat = AC_SRC_ALPHA;
SetGraphicsMode(hdc,GM_ADVANCED);
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
//
// select and realize palette
//
hpal = CreateHtPalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 3 * sizeof(RGBQUAD));
PBITMAPINFOHEADER pbmih = &pbmi->bmiHeader;
pbmih->biSize = sizeof(BITMAPINFOHEADER);
pbmih->biWidth = rect.right;
pbmih->biHeight = 200;
pbmih->biPlanes = 1;
pbmih->biBitCount = 32;
pbmih->biCompression = BI_RGB;
pbmih->biSizeImage = 0;
pbmih->biXPelsPerMeter = 0;
pbmih->biYPelsPerMeter = 0;
pbmih->biClrUsed = 0;
pbmih->biClrImportant = 0;
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
hdibA = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDibA,NULL,0);
if ((hdib == NULL) && (hdibA != NULL))
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
if (SelectObject(hdcmA,hdibA) == NULL)
{
MessageBox(NULL,"error selecting Alpha DIB","Error",MB_OK);
}
}
vert[0].x = xpos;
vert[0].y = ypos;
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = xpos + 100;
vert[1].y = ypos;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x7000;
vert[1].Alpha = 0x0000;
vert[2].x = xpos + 100;
vert[2].y = ypos + 100;
vert[2].Red = 0x0000;
vert[2].Green = 0x7000;
vert[2].Blue = 0x7000;
vert[2].Alpha = 0x0000;
vert[3].x = xpos;
vert[3].y = ypos;
vert[3].Red = 0xff00;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
vert[4].x = xpos+100;
vert[4].y = ypos+100;
vert[4].Red = 0x0000;
vert[4].Green = 0x7000;
vert[4].Blue = 0x7000;
vert[4].Alpha = 0x0000;
vert[5].x = xpos;
vert[5].y = ypos+100;
vert[5].Red = 0x0000;
vert[5].Green = 0x0000;
vert[5].Blue = 0x7000;
vert[5].Alpha = 0x0000;
Tri[0].Vertex1 = 0;
Tri[0].Vertex2 = 1;
Tri[0].Vertex3 = 2;
Tri[1].Vertex1 = 3;
Tri[1].Vertex2 = 4;
Tri[1].Vertex3 = 5;
xpos += 400;
GradientFill(hdc,vert,6,(PVOID)Tri,2,GRADIENT_FILL_TRIANGLE);
xposDib = 0;
yposDib = 0;
vert[0].x = xposDib; vert[0].y = yposDib;
vert[1].x = xposDib+100; vert[1].y = yposDib;
vert[2].x = xposDib+100; vert[2].y = yposDib+100;
vert[3].x = xposDib; vert[3].y = yposDib;
vert[4].x = xposDib+100; vert[4].y = yposDib+100;
vert[5].x = xposDib; vert[5].y = yposDib+100;
GradientFill(hdcm,vert,6,(PVOID)Tri,2,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,xpos,ypos,100,100,hdcm,0,0,100,100,SRCCOPY);
//
// add alpha
//
vert[0].Alpha = 0xff00;
vert[1].Alpha = 0x7000;
vert[2].Alpha = 0x7000;
vert[3].Alpha = 0xff00;
vert[4].Alpha = 0x7000;
vert[5].Alpha = 0x7000;
xpos += 110;
GradientFill(hdcmA,vert,6,(PVOID)Tri,2,GRADIENT_FILL_TRIANGLE);
AlphaBlend(hdc,xpos,ypos,100,100,hdcmA,0,0,100,100,BlendFunction);
xpos = 10+50;
ypos += (110 + 50);
vert[0].x = xpos; //50,200
vert[0].y = ypos;
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0xff00;
vert[1].x = xpos;
vert[1].y = ypos-50;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0xff00;
vert[2].x = xpos+50;
vert[2].y = ypos-25;
vert[2].Red = 0xff00;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0xff00;
vert[3].x = xpos+50;
vert[3].y = ypos+25;
vert[3].Red = 0xff00;
vert[3].Green = 0x0000;
vert[3].Blue = 0xff00;
vert[3].Alpha = 0xff00;
vert[4].x = xpos;
vert[4].y = ypos+50;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0xff00;
vert[4].Alpha = 0xff00;
vert[5].x = xpos-50;
vert[5].y = ypos+25;
vert[5].Red = 0x0000;
vert[5].Green = 0xff00;
vert[5].Blue = 0xff00;
vert[5].Alpha = 0xff00;
vert[6].x = xpos-50;
vert[6].y = ypos-25;
vert[6].Red = 0x0000;
vert[6].Green = 0xff00;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0xff00;
Tri[0].Vertex1 = 0;
Tri[0].Vertex2 = 1;
Tri[0].Vertex3 = 2;
Tri[1].Vertex1 = 0;
Tri[1].Vertex2 = 2;
Tri[1].Vertex3 = 3;
Tri[2].Vertex1 = 0;
Tri[2].Vertex2 = 3;
Tri[2].Vertex3 = 4;
Tri[3].Vertex1 = 0;
Tri[3].Vertex2 = 4;
Tri[3].Vertex3 = 5;
Tri[4].Vertex1 = 0;
Tri[4].Vertex2 = 5;
Tri[4].Vertex3 = 6;
Tri[5].Vertex1 = 0;
Tri[5].Vertex2 = 6;
Tri[5].Vertex3 = 1;
GradientFill(hdc,vert,7,(PVOID)Tri,6,GRADIENT_FILL_TRIANGLE);
vert[0].x += 110;
vert[1].x += 110;
vert[2].x += 110;
vert[3].x += 110;
vert[4].x += 110;
vert[5].x += 110;
vert[6].x += 110;
Tri[0].Vertex1 = 1;
Tri[0].Vertex2 = 2;
Tri[0].Vertex3 = 0;
Tri[1].Vertex1 = 2;
Tri[1].Vertex2 = 3;
Tri[1].Vertex3 = 0;
Tri[2].Vertex1 = 3;
Tri[2].Vertex2 = 4;
Tri[2].Vertex3 = 0;
Tri[3].Vertex1 = 4;
Tri[3].Vertex2 = 5;
Tri[3].Vertex3 = 0;
Tri[4].Vertex1 = 5;
Tri[4].Vertex2 = 6;
Tri[4].Vertex3 = 0;
Tri[5].Vertex1 = 6;
Tri[5].Vertex2 = 1;
Tri[5].Vertex3 = 0;
GradientFill(hdc,vert,7,(PVOID)Tri,6,GRADIENT_FILL_TRIANGLE);
vert[0].x += 110;
vert[1].x += 110;
vert[2].x += 110;
vert[3].x += 110;
vert[4].x += 110;
vert[5].x += 110;
vert[6].x += 110;
Tri[0].Vertex1 = 2;
Tri[0].Vertex2 = 1;
Tri[0].Vertex3 = 0;
Tri[1].Vertex1 = 3;
Tri[1].Vertex2 = 2;
Tri[1].Vertex3 = 0;
Tri[2].Vertex1 = 4;
Tri[2].Vertex2 = 3;
Tri[2].Vertex3 = 0;
Tri[3].Vertex1 = 5;
Tri[3].Vertex2 = 4;
Tri[3].Vertex3 = 0;
Tri[4].Vertex1 = 6;
Tri[4].Vertex2 = 5;
Tri[4].Vertex3 = 0;
Tri[5].Vertex1 = 1;
Tri[5].Vertex2 = 6;
Tri[5].Vertex3 = 0;
GradientFill(hdc,vert,7,(PVOID)Tri,6,GRADIENT_FILL_TRIANGLE);
vert[0].y = 200 - 150;
vert[1].y = 150 - 150;
vert[2].y = 175 - 150;
vert[3].y = 225 - 150;
vert[4].y = 250 - 150;
vert[5].y = 225 - 150;
vert[6].y = 175 - 150;
//
// draw to DIB
//
xpos = 10;
ypos += (110-50);
xposDib = 50;
yposDib = 50;
vert[0].x = xposDib;
vert[0].y = yposDib;
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0xff00;
vert[1].x = xposDib;
vert[1].y = yposDib-50;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0xff00;
vert[2].x = xposDib+50;
vert[2].y = yposDib-25;
vert[2].Red = 0xff00;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0xff00;
vert[3].x = xposDib+50;
vert[3].y = yposDib+25;
vert[3].Red = 0xff00;
vert[3].Green = 0x0000;
vert[3].Blue = 0xff00;
vert[3].Alpha = 0xff00;
vert[4].x = xposDib;
vert[4].y = yposDib+50;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0xff00;
vert[4].Alpha = 0xff00;
vert[5].x = xposDib-50;
vert[5].y = yposDib+25;
vert[5].Red = 0x0000;
vert[5].Green = 0xff00;
vert[5].Blue = 0xff00;
vert[5].Alpha = 0xff00;
vert[6].x = xposDib-50;
vert[6].y = yposDib-25;
vert[6].Red = 0x0000;
vert[6].Green = 0xff00;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0xff00;
BitBlt(hdcm,0,0,128,128,hdc,xpos,ypos,SRCCOPY);
BitBlt(hdcmA,0,0,128,128,hdc,xpos,ypos,SRCCOPY);
GradientFill(hdcm,vert,7,(PVOID)Tri,6,GRADIENT_FILL_TRIANGLE);
//
// add alpha
//
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0xff00;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0xff00;
vert[2].Red = 0xc000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0xc000;
vert[3].Red = 0x8000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x8000;
vert[3].Alpha = 0x8000;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0xc000;
vert[4].Alpha = 0xc000;
vert[5].Red = 0x0000;
vert[5].Green = 0xf000;
vert[5].Blue = 0xf000;
vert[5].Alpha = 0xf000;
vert[6].Red = 0x0000;
vert[6].Green = 0x8000;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0x8000;
PatBlt(hdcmA,0,0,2000,2000,0);
GradientFill(hdcmA,vert,7,(PVOID)Tri,6,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,xpos,ypos,100,100,hdcm,0,0,100,100,SRCCOPY);
xpos += 110;
AlphaBlend(hdc,xpos,ypos,100,100,hdcmA,0,0,100,100,BlendFunction);
BitBlt (hdc,xpos+200,ypos,100,100,hdcmA,0,0,SRCCOPY);
AlphaBlend(hdc,xpos+400,ypos,50,50,hdcmA,10,10,80,80,BlendFunction);
xpos = 0;
ypos += 110;
vert[0].x = xpos;
vert[0].y = ypos;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x1000;
vert[0].Alpha = 0x2000;
vert[1].x = rect.right;
vert[1].y = ypos;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x8000;
vert[1].Alpha = 0xff00;
vert[2].x = rect.right;
vert[2].y = ypos+16;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x8000;
vert[2].Alpha = 0xff00;
vert[3].x = xpos;
vert[3].y = ypos+16;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x1000;
vert[3].Alpha = 0x2000;
Tri[0].Vertex1 = 0;
Tri[0].Vertex2 = 1;
Tri[0].Vertex3 = 2;
Tri[1].Vertex1 = 0;
Tri[1].Vertex2 = 2;
Tri[1].Vertex3 = 3;
GradientFill(hdc,vert,4,(PVOID)Tri,2,GRADIENT_FILL_TRIANGLE);
vert[0].y = 0;
vert[1].y = 0;
vert[2].y = 16;
vert[3].y = 16;
FillTransformedRect(hdcm,&dibRect,(HBRUSH)GetStockObject(BLACK_BRUSH));
FillTransformedRect(hdcmA,&dibRect,(HBRUSH)GetStockObject(BLACK_BRUSH));
GradientFill(hdcm,vert,4,(PVOID)Tri,2,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcmA,vert,4,(PVOID)Tri,2,GRADIENT_FILL_TRIANGLE);
ypos += 20;
StretchBlt(hdc,xpos,ypos,rect.right,16,hdcm,0,0,rect.right,16,SRCCOPY);
ypos += 20;
AlphaBlend(hdc,xpos,ypos,rect.right,16,hdcmA,0,0,rect.right,16,BlendFunction);
ypos += 20;
//
// rectangular clipped triangle
//
vert[0].x = 300;
vert[0].y = ypos;
vert[0].Red = 0xc000;
vert[0].Green = 0xc000;
vert[0].Blue = 0xc000;
vert[0].Alpha = 0x0000;
vert[1].x = 4000;
vert[1].y = 3000;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = xpos;
vert[2].y = ypos+100;
vert[2].Red = 0x4000;
vert[2].Green = 0x4000;
vert[2].Blue = 0x4000;
vert[2].Alpha = 0x0000;
Tri[0].Vertex1 = 0;
Tri[0].Vertex2 = 1;
Tri[0].Vertex3 = 2;
GradientFill(hdc,vert,3,(PVOID)Tri,1,GRADIENT_FILL_TRIANGLE);
ypos += 110;
//
// complex clipping
//
{
HRGN hrgn1 = CreateEllipticRgn(xpos,ypos,xpos+100,ypos+100);
ExtSelectClipRgn(hdc,hrgn1,RGN_COPY);
vert[0].x = 166;
vert[0].y = ypos;
vert[0].Red = 0xc000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = 140;
vert[1].y = ypos+120;
vert[1].Red = 0x8000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 80;
vert[2].y = ypos+50;
vert[2].Red = 0x4000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x4000;
vert[2].Alpha = 0x0000;
Tri[0].Vertex1 = 0;
Tri[0].Vertex2 = 1;
Tri[0].Vertex3 = 2;
GradientFill(hdc,vert,3,(PVOID)Tri,1,GRADIENT_FILL_TRIANGLE);
ExtSelectClipRgn(hdc,NULL,RGN_COPY);
DeleteObject(hrgn1);
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
DeleteDC(hdcm);
DeleteDC(hdcmA);
DeleteObject(hdib);
DeleteObject(hdibA);
bThreadActive = FALSE;
}
/**************************************************************************\
* vRunGradMap
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/17/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestGradMap(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
CHAR msg[255];
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// grad fill and patblt rects with different map modes and origins
//
ULONG xpos = 10;
ULONG ypos = 10;
ULONG dy = 10;
ULONG dx = 10;
RECT rect;
SelectObject(hdc,hTestFont);
//
// Clear screen
//
SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdc,0,0,2000,2000,PATCOPY);
SelectObject(hdc,hbrFillCars);
SetTextColor(hdc,RGB(255,255,255));
SetBkMode(hdc,TRANSPARENT);
GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};
GRADIENT_RECT gRect = {0,1};
TRIVERTEX vert[6];
//
// fill screen background
//
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0x4000;
vert[0].Green = 0x8000;
vert[0].Blue = 0xc000;
vert[0].Alpha = 0x0000;
vert[1].x = 80;
vert[1].y = 80;
vert[1].Red = 0xc000;
vert[1].Green = 0x8000;
vert[1].Blue = 0x4000;
vert[1].Alpha = 0x0000;
//
// MM_TEXT
//
LONG ux,uy;
for (uy = -400; uy <= 400;uy += 100)
{
for (ux = -400; ux <= 400;ux += 100)
{
SetWindowOrgEx(hdc,ux,uy,NULL);
GradientFill(hdc,vert,2,(PVOID)&gRect,1,GRADIENT_FILL_RECT_H);
PatBlt(hdc,30,30,20,20,PATCOPY);
wsprintf(msg,"%li,%li",ux,uy);
TextOut(hdc,10,10,msg,strlen(msg));
}
}
SetWindowOrgEx(hdc,0,0,NULL);
Sleep(gAlphaSleep);
//
// isotropic stretch
//
SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdc,0,0,2000,2000,PATCOPY);
SelectObject(hdc,hbrFillCars);
SetMapMode(hdc,MM_ISOTROPIC);
SetViewportExtEx(hdc,1000,1000,NULL);
SetViewportOrgEx(hdc,0,0,NULL);
SetWindowExtEx(hdc,2000,2000,NULL);
SetWindowOrgEx(hdc,0,0,NULL);
for (uy = -400; uy <= 400;uy += 100)
{
for (ux = -400; ux <= 400;ux += 100)
{
SetWindowOrgEx(hdc,ux,uy,NULL);
GradientFill(hdc,vert,2,(PVOID)&gRect,1,GRADIENT_FILL_RECT_H);
PatBlt(hdc,30,30,20,20,PATCOPY);
wsprintf(msg,"%li,%li",ux,uy);
TextOut(hdc,10,10,msg,strlen(msg));
}
}
SetWindowOrgEx(hdc,0,0,NULL);
SetMapMode(hdc,MM_TEXT);
Sleep(gAlphaSleep);
//
// isotropic shrink
//
SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdc,0,0,2000,2000,PATCOPY);
SelectObject(hdc,hbrFillCars);
SetMapMode(hdc,MM_ISOTROPIC);
SetViewportExtEx(hdc,1500,1500,NULL);
SetViewportOrgEx(hdc,0,0,NULL);
SetWindowExtEx(hdc,1000,1000,NULL);
SetWindowOrgEx(hdc,0,0,NULL);
for (uy = -400; uy <= 400;uy += 100)
{
for (ux = -400; ux <= 400;ux += 100)
{
SetWindowOrgEx(hdc,ux,uy,NULL);
GradientFill(hdc,vert,2,(PVOID)&gRect,1,GRADIENT_FILL_RECT_H);
PatBlt(hdc,30,30,20,20,PATCOPY);
wsprintf(msg,"%li,%li",ux,uy);
TextOut(hdc,10,10,msg,strlen(msg));
}
}
SetWindowOrgEx(hdc,0,0,NULL);
SetMapMode(hdc,MM_TEXT);
Sleep(gAlphaSleep);
//
// anisotropic
//
SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdc,0,0,2000,2000,PATCOPY);
SelectObject(hdc,hbrFillCars);
SetMapMode(hdc,MM_ANISOTROPIC);
SetViewportExtEx(hdc,2000,1000,NULL);
SetViewportOrgEx(hdc,0,0,NULL);
SetWindowExtEx(hdc,1000,2000,NULL);
SetWindowOrgEx(hdc,0,0,NULL);
for (uy = -400; uy <= 400;uy += 100)
{
for (ux = -400; ux <= 400;ux += 100)
{
SetWindowOrgEx(hdc,ux,uy,NULL);
GradientFill(hdc,vert,2,(PVOID)&gRect,1,GRADIENT_FILL_RECT_H);
PatBlt(hdc,30,30,20,20,PATCOPY);
wsprintf(msg,"%li,%li",ux,uy);
TextOut(hdc,10,10,msg,strlen(msg));
}
}
SetWindowOrgEx(hdc,0,0,NULL);
SetMapMode(hdc,MM_TEXT);
//
// free objects
//
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vTestOverflow
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/17/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestOverflow(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
CHAR msg[255];
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// grad fill and patblt rects with different map modes and origins
//
ULONG xpos = 10;
ULONG ypos = 10;
ULONG dx = 120;
ULONG dy = 20;
RECT rect;
SelectObject(hdc,hTestFont);
//
// Clear screen
//
SelectObject(hdc,GetStockObject(LTGRAY_BRUSH));
PatBlt(hdc,0,0,2000,2000,PATCOPY);
SelectObject(hdc,hbrFillCars);
SetTextColor(hdc,RGB(255,255,255));
SetBkMode(hdc,TRANSPARENT);
GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};
GRADIENT_RECT gRect[]= {{0,1},{2,3},{4,5},{6,7}};
TRIVERTEX vert[6];
vert[0].x = xpos;
vert[0].y = ypos;
vert[0].Red = 0xa000;
vert[0].Green = 0xc000;
vert[0].Blue = 0xc000;
vert[0].Alpha = 0x0000;
vert[1].x = xpos+dx;
vert[1].y = ypos;
vert[1].Red = 0xc000;
vert[1].Green = 0xc000;
vert[1].Blue = 0xc000;
vert[1].Alpha = 0x0000;
vert[2].x = xpos+dx;
vert[2].y = ypos+dy;
vert[2].Red = 0xc000;
vert[2].Green = 0xc000;
vert[2].Blue = 0xc000;
vert[2].Alpha = 0x0000;
vert[3].x = xpos;
vert[3].y = ypos+dy;
vert[3].Red = 0xa000;
vert[3].Green = 0xc000;
vert[3].Blue = 0xc000;
vert[3].Alpha = 0x0000;
GradientFill(hdc,vert,4,&gTri,2,GRADIENT_FILL_TRIANGLE);
vert[0].x = xpos;
vert[0].y = ypos+dy;
vert[0].Red = 0x8000;
vert[0].Green = 0x8000;
vert[0].Blue = 0x8000;
vert[0].Alpha = 0x0000;
vert[1].x = xpos+dx+2;
vert[1].y = ypos+dy+2;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
GradientFill(hdc,vert,8,&gRect,1,GRADIENT_FILL_RECT_V);
vert[0].x = xpos+dx;
vert[0].y = ypos;
vert[0].Red = 0x8000;
vert[0].Green = 0x8000;
vert[0].Blue = 0x8000;
vert[0].Alpha = 0x0000;
vert[1].x = xpos+dx+2;
vert[1].y = ypos+dy;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = xpos;
vert[2].y = ypos;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
vert[3].x = xpos+dx+1;
vert[3].y = ypos+1;
vert[3].Red = 0xff00;
vert[3].Green = 0xff00;
vert[3].Blue = 0xff00;
vert[3].Alpha = 0x0000;
vert[4].x = xpos;
vert[4].y = ypos;
vert[4].Red = 0xff00;
vert[4].Green = 0xff00;
vert[4].Blue = 0xff00;
vert[4].Alpha = 0x0000;
vert[5].x = xpos+1;
vert[5].y = ypos+dy+1;
vert[5].Red = 0xff00;
vert[5].Green = 0xff00;
vert[5].Blue = 0xff00;
vert[5].Alpha = 0x0000;
GradientFill(hdc,vert,8,&gRect,3,GRADIENT_FILL_RECT_H);
//
// free objects
//
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vTestCircle1
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestCircle1(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
CHAR Title[256];
CHAR NewTitle[256];
GetWindowText(pCallData->hwnd,Title,256);
//
// repeat for each src format
//
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};
GRADIENT_RECT gRect = {0,1};
TRIVERTEX vert[6];
POINT pos = {150,150};
double fr = 300.0;
double fTheta = 0.0;
double fdTheta = 0.01;
PatBlt(hdc,0,0,5000,5000,0);
//
// fade to back at 0,0
//
fTheta = 0.0;
vert[0].x = pos.x;
vert[0].y = pos.y;
vert[0].Red = 0x2000;
vert[0].Green = 0xa000;
vert[0].Blue = 0xe000;
vert[0].Alpha = 0x0000;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
fTheta = 0;
double fLimit = (2.0 * fdTheta) * 4.0;
while (fTheta < (2.0 * 3.14159265))
{
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
GradientFill(hdc,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vTestCircle2
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestCircle2(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
RECT rcl;
GetClientRect(pCallData->hwnd,&rcl);
//
// repeat for each src format
//
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};
GRADIENT_RECT gRect = {0,1};
TRIVERTEX vert[6];
POINT pos = {100,100};
double fr = 1000.0;
double fTheta = 0.0;
double fdTheta = 0.001;
PatBlt(hdc,0,0,5000,5000,0);
//
// solid color
//
fr = 100.0;
fTheta = 0.0;
vert[0].x = pos.x;
vert[0].y = pos.y;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].Red = 0x0000;
vert[1].Green = 0xcf00;
vert[1].Blue = 0xcf00;
vert[1].Alpha = 0x0000;
vert[2].Red = 0x0000;
vert[2].Green = 0xcf00;
vert[2].Blue = 0xcf00;
vert[2].Alpha = 0x0000;
while (fTheta < (2.0 * 3.14159265))
{
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
vert[1].Red = 0x8000 + (SHORT)((double)0x7f00 * cos(fTheta));
vert[1].Green = 0x8000 + (SHORT)((double)0x7f00 * sin(fTheta));
vert[1].Blue = 0x8000 + (SHORT)((double)0x3f00 * cos(fTheta)) + (SHORT)((double)0x3f00 * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
vert[2].Red = 0x8000 + (SHORT)((double)0x7f00 * cos(fTheta));
vert[2].Green = 0x8000 + (SHORT)((double)0x7f00 * sin(fTheta));
vert[2].Blue = 0x8000 + (SHORT)((double)0x3f00 * cos(fTheta)) + (SHORT)((double)0x3f00 * sin(fTheta));
GradientFill(hdc,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
//
// separate triangles
//
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].Red = 0x0000;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
fr = 500.0;
fTheta = 0.0;
fdTheta = 0.02;
pos.x = rcl.right/2;
pos.y = rcl.bottom/2;
while (fTheta < (2.0 * 3.14159265))
{
vert[0].x = (LONG)(pos.x + 20.0 * cos(fTheta));
vert[0].y = (LONG)(pos.y + 20.0 * sin(fTheta));
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
GradientFill(hdc,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vTestCircle3
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestCircle3(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
RECT rcl;
GetClientRect(pCallData->hwnd,&rcl);
//
// repeat for each src format
//
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};
GRADIENT_RECT gRect = {0,1};
TRIVERTEX vert[6];
//double fr = 65536.0;
double fr = 200.0;
double fTheta = 0.0;
double fdTheta = 0.01;
POINT pos = {0,0};
//
// separate triangles
//
vert[0].Red = 0xcc00;
vert[0].Green = 0x4400;
vert[0].Blue = 0x6600;
vert[0].Alpha = 0x0000;
vert[1].Red = 0x6600;
vert[1].Green = 0xcc00;
vert[1].Blue = 0x4400;
vert[1].Alpha = 0x0000;
vert[2].Red = 0x4400;
vert[2].Green = 0x6600;
vert[2].Blue = 0xcc00;
vert[2].Alpha = 0x0000;
do
{
PatBlt(hdc,0,0,5000,5000,0);
pos.x = 0;
pos.y = 0;
fTheta = 0.0;
while (fTheta < (2.0 * 3.14159265))
{
vert[0].x = (LONG)(pos.x + 20.0 * cos(fTheta));
vert[0].y = (LONG)(pos.y + 20.0 * sin(fTheta));
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
GradientFill(hdc,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
Sleep(200);
PatBlt(hdc,0,0,5000,5000,0);
pos.x = rcl.right;
pos.y = 0;
fTheta = 0.0;
while (fTheta < (2.0 * 3.14159265))
{
vert[0].x = (LONG)(pos.x + 20.0 * cos(fTheta));
vert[0].y = (LONG)(pos.y + 20.0 * sin(fTheta));
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
GradientFill(hdc,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
Sleep(200);
PatBlt(hdc,0,0,5000,5000,0);
pos.x = rcl.right;
pos.y = rcl.bottom;
fTheta = 0.0;
while (fTheta < (2.0 * 3.14159265))
{
vert[0].x = (LONG)(pos.x + 20.0 * cos(fTheta));
vert[0].y = (LONG)(pos.y + 20.0 * sin(fTheta));
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
GradientFill(hdc,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
Sleep(200);
PatBlt(hdc,0,0,5000,5000,0);
pos.x = 0;
pos.y = rcl.bottom;
fTheta = 0.0;
while (fTheta < (2.0 * 3.14159265))
{
vert[0].x = (LONG)(pos.x + 20.0 * cos(fTheta));
vert[0].y = (LONG)(pos.y + 20.0 * sin(fTheta));
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
GradientFill(hdc,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
Sleep(200);
fr *= 2.0;
} while (fr < 131072.0);
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vTestMenu
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 5/15/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestMenu(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
LONG xpos = 0;
MENUINFO mi;
{
mi.cbSize = sizeof(mi);
mi.fMask = MIM_BACKGROUND | MIM_APPLYTOSUBMENUS;
mi.hbrBack = CreateHatchBrush(HS_BDIAGONAL, RGB(255, 0, 0));
// mi.hbrBack = CreateSolidBrush(RGB(255, 0, 0));
SetMenuInfo(GetMenu(pCallData->hwnd), &mi);
}
HBRUSH hbr1 = CreateHatchBrush(HS_BDIAGONAL, RGB(255, 0, 0));
HBRUSH hbr2 = CreateHatchBrush(HS_BDIAGONAL, RGB( 0, 255, 0));
HBRUSH hbr3 = CreateHatchBrush(HS_BDIAGONAL, RGB( 0, 0, 255));
HBRUSH hbr4 = CreateSolidBrush(RGB(255,255,0));
PatBlt(hdc,0,0,5000,5000,0);
SetBkColor(hdc,RGB(0,0,0));
SelectObject(hdc,hbr1);
PatBlt(hdc,xpos,0,8,8,PATCOPY);
SelectObject(hdc,hbr2);
PatBlt(hdc,xpos,16,8,8,PATCOPY);
SelectObject(hdc,hbr3);
PatBlt(hdc,xpos,32,8,8,PATCOPY);
SelectObject(hdc,hbr4);
PatBlt(hdc,xpos,48,8,8,PATCOPY);
SetBkColor(hdc,RGB(255,0,0));
xpos += 16;
SelectObject(hdc,hbr1);
PatBlt(hdc,xpos,0,8,8,PATCOPY);
SelectObject(hdc,hbr2);
PatBlt(hdc,xpos,16,8,8,PATCOPY);
SelectObject(hdc,hbr3);
PatBlt(hdc,xpos,32,8,8,PATCOPY);
SelectObject(hdc,hbr4);
PatBlt(hdc,xpos,48,8,8,PATCOPY);
SetBkColor(hdc,RGB(0,255,0));
xpos += 16;
SelectObject(hdc,hbr1);
PatBlt(hdc,xpos,0,8,8,PATCOPY);
SelectObject(hdc,hbr2);
PatBlt(hdc,xpos,16,8,8,PATCOPY);
SelectObject(hdc,hbr3);
PatBlt(hdc,xpos,32,8,8,PATCOPY);
SelectObject(hdc,hbr4);
PatBlt(hdc,xpos,48,8,8,PATCOPY);
SetBkColor(hdc,RGB(0,0,255));
xpos += 16;
SelectObject(hdc,hbr1);
PatBlt(hdc,xpos,0,8,8,PATCOPY);
SelectObject(hdc,hbr2);
PatBlt(hdc,xpos,16,8,8,PATCOPY);
SelectObject(hdc,hbr3);
PatBlt(hdc,xpos,32,8,8,PATCOPY);
SelectObject(hdc,hbr4);
PatBlt(hdc,xpos,48,8,8,PATCOPY);
SetBkColor(hdc,RGB(255,255,255));
xpos += 16;
SelectObject(hdc,hbr1);
PatBlt(hdc,xpos,0,8,8,PATCOPY);
SelectObject(hdc,hbr2);
PatBlt(hdc,xpos,16,8,8,PATCOPY);
SelectObject(hdc,hbr3);
PatBlt(hdc,xpos,32,8,8,PATCOPY);
SelectObject(hdc,hbr4);
PatBlt(hdc,xpos,48,8,8,PATCOPY);
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hbr1);
DeleteObject(hbr2);
DeleteObject(hbr3);
DeleteObject(hbr4);
}
/**************************************************************************\
* vTestDiamond
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 5/15/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestDiamond(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};
GRADIENT_RECT gRect = {0,1};
TRIVERTEX vert[6];
RECT rcl;
GetClientRect(pCallData->hwnd,&rcl);
//
// background
//
vert[0].x = 0x0;
vert[0].y = 0x0;
vert[0].Red = 0x0000;
vert[0].Green = 0x8000;
vert[0].Blue = 0x8000;
vert[0].Alpha = 0x0000;
vert[1].x = rcl.right;
vert[1].y = 0;
vert[1].Red = 0x0000;
vert[1].Green = 0x4000;
vert[1].Blue = 0x8000;
vert[1].Alpha = 0x0000;
vert[2].x = rcl.right;
vert[2].y = rcl.bottom;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x8000;
vert[2].Alpha = 0x0000;
vert[3].x = 0;
vert[3].y = rcl.bottom;
vert[3].Red = 0x0000;
vert[3].Green = 0x4000;
vert[3].Blue = 0x8000;
vert[3].Alpha = 0x0000;
GradientFill(hdc,vert,4,&gTri,2,GRADIENT_FILL_TRIANGLE);
//
// Diamond
//
vert[0].x = 70;
vert[0].y = 150;
vert[0].Red = 0xff00;
vert[0].Green = 0xa000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = 100;
vert[1].y = 100;
vert[1].Red = 0xff00;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 130;
vert[2].y = 150;
vert[2].Red = 0xff00;
vert[2].Green = 0x6000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
vert[3].x = 100;
vert[3].y = 200;
vert[3].Red = 0xff00;
vert[3].Green = 0xff00;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
GradientFill(hdc,vert,4,&gTri,2,GRADIENT_FILL_TRIANGLE);
//
// circle with alpha
//
BITMAPINFO bmi;
PBITMAPINFOHEADER pbmih = &bmi.bmiHeader;
pbmih->biSize = sizeof(BITMAPINFOHEADER);
pbmih->biWidth = 128;
pbmih->biHeight = 128;
pbmih->biPlanes = 1;
pbmih->biBitCount = 32;
pbmih->biCompression = BI_RGB;
pbmih->biSizeImage = 0;
pbmih->biXPelsPerMeter = 0;
pbmih->biYPelsPerMeter = 0;
pbmih->biClrUsed = 0;
pbmih->biClrImportant = 0;
PULONG pDib32RGB;
HBITMAP hdib32RGB = CreateDIBSection(hdc,&bmi,DIB_RGB_COLORS,(VOID **)&pDib32RGB,NULL,0);
HDC hdcm = CreateCompatibleDC(hdc);
SelectObject(hdcm,hdib32RGB);
PatBlt(hdcm,0,0,5000,5000,0);
POINT pos = {64,64};
double fr = 32.0;
double fTheta = 0.0;
double fdTheta = 0.1;
//
// fade to back at 0,0
//
fTheta = 0.0;
vert[0].x = pos.x;
vert[0].y = pos.y;
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0xff00;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
fTheta = 0;
double fLimit = (2.0 * fdTheta) * 4.0;
while (fTheta < (2.0 * 3.14159265))
{
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
GradientFill(hdcm,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
BLENDFUNCTION BlendFunction;
BlendFunction.BlendOp = AC_SRC_OVER;
BlendFunction.BlendFlags = 0;
BlendFunction.SourceConstantAlpha = 0xfe;
BlendFunction.AlphaFormat = AC_SRC_ALPHA;
AlphaBlend(hdc,100-64,100-64,128,128,hdcm,0,0,128,128,BlendFunction);
DeleteDC(hdcm);
DeleteObject(hdib32RGB);
ReleaseDC(pCallData->hwnd,hdc);
}
/**************************************************************************\
* vTestBitBlt
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 5/15/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestBitBlt(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
//
// tile screen
//
{
RECT rect;
GetClientRect(pCallData->hwnd,&rect);
FillTransformedRect(hdc,&rect,hbrFillCars);
}
BitBlt(hdc,100,100,200,200,hdc,0,0,NOTSRCCOPY);
BitBlt(hdc,400,100,200,200,hdc,500,0,NOTSRCCOPY);
BitBlt(hdc,100,400,200,200,hdc,0,500,NOTSRCCOPY);
BitBlt(hdc,400,400,200,200,hdc,500,500,NOTSRCCOPY);
ReleaseDC(pCallData->hwnd,hdc);
}
VOID
vTestBitBlt2(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
//
// tile screen
//
{
RECT rect;
GetClientRect(pCallData->hwnd,&rect);
FillTransformedRect(hdc,&rect,hbrFillCars);
}
BitBlt(hdc,100,100,200,200,hdc,0,0,NOTSRCCOPY);
BitBlt(hdc,200,000,200,200,hdc,100,100,NOTSRCCOPY);
ReleaseDC(pCallData->hwnd,hdc);
}
VOID
vTestBitBlt3(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GdiSetBatchLimit(1);
//
// tile screen
//
ULONG ulIndex = 0;
HBITMAP hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],350,350);
HDC hdcm = CreateCompatibleDC(hdc);
SelectObject(hdcm,hdib);
PatBlt(hdc ,0,0,5000,5000,0);
PatBlt(hdcm,0,0,5000,5000,0);
HBRUSH hBrush = (HBRUSH)SelectObject(hdcm,CreateSolidBrush(RGB(255, 255, 255 )));
Rectangle(hdcm, 0, 0, 200, 200);
hBrush = (HBRUSH)SelectObject(hdcm,CreateSolidBrush(RGB(255, 0,0 )));
Ellipse(hdcm, 50, 50, 350, 350);
BitBlt( hdcm, 100, 100, 200, 200, hdcm, 0, 0, NOTSRCCOPY );
BitBlt( hdc,0,0, 350, 350, hdcm, 0, 0, SRCCOPY );
GdiSetBatchLimit(0);
ReleaseDC(pCallData->hwnd,hdc);
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestGradRectH(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_RECT gRect[10];
GRADIENT_TRIANGLE gTri[10];
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
HDC hdcmA = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
PBITMAPINFOHEADER pbmih;
HBITMAP hdib;
HBITMAP hdibA;
PBYTE pDib;
PBYTE pDibA;
BLENDFUNCTION BlendFunction;
//
// tile screen
//
{
RECT rect;
HBITMAP hbmCars = LoadBitmap(hInstMain,MAKEINTRESOURCE(CAR_BITMAP));
LOGBRUSH lgBrush;
HBRUSH hbrFill;
lgBrush.lbStyle = BS_PATTERN;
lgBrush.lbColor = 0;
lgBrush.lbHatch = (LONG)hbmCars;
hbrFill = CreateBrushIndirect(&lgBrush);
GetClientRect(pCallData->hwnd,&rect);
FillTransformedRect(hdc,&rect,hbrFill);
DeleteObject(hbrFill);
DeleteObject(hbmCars);
}
//
// init drawing modes
//
SetStretchBltMode(hdc,HALFTONE);
BlendFunction.BlendOp = AC_SRC_OVER;
BlendFunction.BlendFlags = 0;
BlendFunction.SourceConstantAlpha = 255;
SetGraphicsMode(hdc,GM_ADVANCED);
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
//
// select and realize palette
//
hpal = CreateHtPalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
pbmih = (PBITMAPINFOHEADER)&pbmi->bmiHeader;
pbmih->biSize = sizeof(BITMAPINFOHEADER);
pbmih->biWidth = rect.right;
pbmih->biHeight = 200;
pbmih->biPlanes = 1;
pbmih->biBitCount = 32;
pbmih->biCompression = BI_RGB;
pbmih->biSizeImage = 0;
pbmih->biXPelsPerMeter = 0;
pbmih->biYPelsPerMeter = 0;
pbmih->biClrUsed = 0;
pbmih->biClrImportant = 0;
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
PULONG pulMask = (PULONG)&pbmi->bmiColors[0];
pulMask[0] = 0x00ff0000;
pulMask[1] = 0x0000ff00;
pulMask[2] = 0x000000ff;
pbmih->biCompression = BI_BITFIELDS;
hdibA = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDibA,NULL,0);
if ((hdib == NULL) && (hdibA != NULL))
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
if (SelectObject(hdcmA,hdibA) == NULL)
{
MessageBox(NULL,"error selecting Alpha DIB","Error",MB_OK);
}
}
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0xff00;
vert[1].x = 100;
vert[1].y = 100;
vert[1].Red = 0x0000;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0xff00;
gRect[0].UpperLeft = 0;
gRect[0].LowerRight = 1;
GradientFill(hdc,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_H);
GradientFill(hdcm,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_H);
SetStretchBltMode(hdc,COLORONCOLOR);
StretchBlt(hdc,120, 0,100,100,hdcm,0,0,100,100,SRCCOPY);
SetStretchBltMode(hdc,HALFTONE);
StretchBlt(hdc,240, 0,100,100,hdcm,0,0,100,100,SRCCOPY);
//
// add alpha
//
vert[0].Red = 0x8400;
vert[0].Alpha = 0x8400;
vert[1].Green = 0x4000;
vert[1].Alpha = 0x4000;
GradientFill(hdcmA,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_H);
AlphaBlend(hdc,360,0,100,100,hdcmA,0,0,100,100,BlendFunction);
BitBlt(hdc,480,0,100,100,hdcmA,0,0,SRCCOPY);
vert[0].x = 0;
vert[0].y = 110;
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = 100;
vert[1].y = 110;
vert[1].Red = 0x0000;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 100;
vert[2].y = 210;
vert[2].Red = 0x0000;
vert[2].Green = 0xff00;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
vert[3].x = 0;
vert[3].y = 210;
vert[3].Red = 0xff00;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
gTri[0].Vertex1 = 0;
gTri[0].Vertex2 = 1;
gTri[0].Vertex3 = 2;
gTri[1].Vertex1 = 0;
gTri[1].Vertex2 = 2;
gTri[1].Vertex3 = 3;
GradientFill(hdc,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
//
// zero offset
//
vert[0].y = 0;
vert[1].y = 0;
vert[2].y = 100;
vert[3].y = 100;
GradientFill(hdcm,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
SetStretchBltMode(hdc,COLORONCOLOR);
StretchBlt(hdc,120,110,100,100,hdcm,0,0,100,100,SRCCOPY);
SetStretchBltMode(hdc,HALFTONE);
StretchBlt(hdc,240,110,100,100,hdcm,0,0,100,100,SRCCOPY);
//
// add alpha
//
vert[0].Red = 0x8400;
vert[0].Alpha = 0x8400;
vert[1].Green = 0x4000;
vert[1].Alpha = 0x4000;
vert[2].Green = 0x4000;
vert[2].Alpha = 0x4000;
vert[3].Red = 0x8400;
vert[3].Alpha = 0x8400;
GradientFill(hdcmA,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
AlphaBlend(hdc,360,110,100,100,hdcmA,0,0,100,100,BlendFunction);
BitBlt(hdc,480,110,100,100,hdcmA,0,0,SRCCOPY);
//
// banners
//
vert[0].x = 0;
vert[0].y = 300;
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = 600;
vert[1].y = 330;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 0;
vert[2].y = 332;
vert[2].Red = 0x0000;
vert[2].Green = 0xff00;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
vert[3].x = 600;
vert[3].y = 362;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
vert[4].x = 0;
vert[4].y = 364;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0xff00;
vert[4].Alpha = 0x0000;
vert[5].x = 600;
vert[5].y = 395;
vert[5].Red = 0x0000;
vert[5].Green = 0x0000;
vert[5].Blue = 0x0000;
vert[5].Alpha = 0x0000;
vert[6].x = 0;
vert[6].y = 400;
vert[6].Red = 0x0000;
vert[6].Green = 0x0000;
vert[6].Blue = 0xff00;
vert[6].Alpha = 0x0000;
vert[7].x = 600;
vert[7].y = 430;
vert[7].Red = 0xff00;
vert[7].Green = 0xff00;
vert[7].Blue = 0x0000;
vert[7].Alpha = 0x0000;
gRect[0].UpperLeft = 0;
gRect[0].LowerRight = 1;
gRect[1].UpperLeft = 2;
gRect[1].LowerRight = 3;
gRect[2].UpperLeft = 4;
gRect[2].LowerRight = 5;
gRect[3].UpperLeft = 6;
gRect[3].LowerRight = 7;
GradientFill(hdc,vert,8,(PVOID)gRect,4,GRADIENT_FILL_RECT_H);
//
// banner triangles
//
vert[0].x = 0;
vert[0].y = 432;
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = 600;
vert[1].y = 432;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 600;
vert[2].y = 463;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
vert[3].x = 0;
vert[3].y = 463;
vert[3].Red = 0xff00;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
gTri[0].Vertex1 = 0;
gTri[0].Vertex2 = 1;
gTri[0].Vertex3 = 2;
gTri[1].Vertex1 = 0;
gTri[1].Vertex2 = 2;
gTri[1].Vertex3 = 3;
GradientFill(hdc,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
vert[0].x = 0;
vert[0].y = 464;
vert[0].Red = 0x0000;
vert[0].Green = 0xff00;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = 600;
vert[1].y = 464;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 600;
vert[2].y = 495;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
vert[3].x = 0;
vert[3].y = 495;
vert[3].Red = 0x0000;
vert[3].Green = 0xff00;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
GradientFill(hdc,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
vert[0].x = 0;
vert[0].y = 500;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0x0000;
vert[1].x = 600;
vert[1].y = 500;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 600;
vert[2].y = 530;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
vert[3].x = 0;
vert[3].y = 530;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0xff00;
vert[3].Alpha = 0x0000;
GradientFill(hdc,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
vert[0].x = 0;
vert[0].y = 532;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0x0000;
vert[1].x = 600;
vert[1].y = 532;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 600;
vert[2].y = 563;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0x0000;
vert[3].x = 0;
vert[3].y = 563;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0xff00;
vert[3].Alpha = 0x0000;
GradientFill(hdc,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
DeleteDC(hdcm);
DeleteDC(hdcmA);
DeleteObject(hdib);
DeleteObject(hdibA);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestGradRectV(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_RECT gRect[10];
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
HDC hdcmA = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
PBITMAPINFOHEADER pbmih;
HBITMAP hdib;
HBITMAP hdibA;
PBYTE pDib;
PBYTE pDibA;
BLENDFUNCTION BlendFunction;
LONG xAlign;
LONG xpos = 0;
LONG ypos = 0;
//
// tile screen
//
{
RECT rect;
HBITMAP hbmCars = LoadBitmap(hInstMain,MAKEINTRESOURCE(CAR_BITMAP));
LOGBRUSH lgBrush;
HBRUSH hbrFill;
lgBrush.lbStyle = BS_PATTERN;
lgBrush.lbColor = 0;
lgBrush.lbHatch = (LONG)hbmCars;
hbrFill = CreateBrushIndirect(&lgBrush);
GetClientRect(pCallData->hwnd,&rect);
FillTransformedRect(hdc,&rect,hbrFill);
DeleteObject(hbrFill);
DeleteObject(hbmCars);
}
//
// init drawing modes
//
SetStretchBltMode(hdc,HALFTONE);
BlendFunction.BlendOp = AC_SRC_OVER;
BlendFunction.BlendFlags = 0;
BlendFunction.SourceConstantAlpha = 255;
SetGraphicsMode(hdc,GM_ADVANCED);
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
//
// select and realize palette
//
hpal = CreateHtPalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
pbmih = (PBITMAPINFOHEADER)&pbmi->bmiHeader;
pbmih->biSize = sizeof(BITMAPINFOHEADER);
pbmih->biWidth = rect.right;
pbmih->biHeight = 200;
pbmih->biPlanes = 1;
pbmih->biBitCount = 32;
pbmih->biCompression = BI_RGB;
pbmih->biSizeImage = 0;
pbmih->biXPelsPerMeter = 0;
pbmih->biYPelsPerMeter = 0;
pbmih->biClrUsed = 0;
pbmih->biClrImportant = 0;
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
PULONG pulMask = (PULONG)&pbmi->bmiColors[0];
pulMask[0] = 0x00ff0000;
pulMask[1] = 0x0000ff00;
pulMask[2] = 0x000000ff;
pbmih->biCompression = BI_BITFIELDS;
hdibA = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDibA,NULL,0);
if ((hdib == NULL) && (hdibA != NULL))
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
if (SelectObject(hdcmA,hdibA) == NULL)
{
MessageBox(NULL,"error selecting Alpha DIB","Error",MB_OK);
}
}
vert[0].x = -100;
vert[0].y = -100;
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0xff00;
vert[1].x = 1300;
vert[1].y = 100;
vert[1].Red = 0x0000;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0xff00;
gRect[0].UpperLeft = 0;
gRect[0].LowerRight = 1;
GradientFill(hdc,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_V);
xpos = 0;
ypos = 110;
for (xAlign=0;xAlign<8;xAlign++)
{
vert[0].x = xAlign;
vert[0].y = ypos;
vert[0].Red = 0x8000;
vert[0].Green = 0xc000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0xff00;
ypos += 30;
vert[1].x = vert[0].x + 31;
vert[1].y = ypos+2;
vert[1].Red = 0x0000;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0xff00;
ypos += 5;
vert[2].x = vert[0].x + 7;
vert[2].y = ypos;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0xff00;
ypos += 30;
vert[3].x = vert[2].x + 32;
vert[3].y = ypos+3;
vert[3].Red = 0x0000;
vert[3].Green = 0xff00;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0xff00;
gRect[0].UpperLeft = 0;
gRect[0].LowerRight = 1;
gRect[1].UpperLeft = 2;
gRect[1].LowerRight = 3;
GradientFill(hdc,vert,4,(PVOID)gRect,2,GRADIENT_FILL_RECT_V);
ypos += 5;
}
ypos = 110;
xpos = 100;
{
LONG xAlign;
for (xAlign=0;xAlign<8;xAlign++)
{
LONG ix,iy;
LONG width = 1;
for (ix=xpos+xAlign;ix<2000;ix+=32)
{
vert[0].x = ix;
vert[0].y = ypos;
vert[0].Red = 0x4000;
vert[0].Green = 0x4000;
vert[0].Blue = 0x4000;
vert[0].Alpha = 0xff00;
vert[1].x = ix + width;
vert[1].y = ypos+32;
vert[1].Red = 0xc000;
vert[1].Green = 0xc000;
vert[1].Blue = 0xc000;
vert[1].Alpha = 0xff00;
GradientFill(hdc,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_V);
width++;
}
ypos += 40;
}
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
DeleteDC(hdcm);
DeleteDC(hdcmA);
DeleteObject(hdibA);
DeleteObject(hdib);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestGradRect4(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_RECT gRect[2] = {{0,1},{2,3}};
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{3,4,5}};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm4 = CreateCompatibleDC(hdc);
HBITMAP hdib4;
PBYTE pDib4;
PBITMAPINFO pbmi;
PBITMAPINFOHEADER pbih;
ULONG ux,uy;
PULONG pulColors;
ULONG ulVGA[] = {
0x00000000,
0x00800000,
0x00008000,
0x00808000,
0x00000080,
0x00800080,
0x00008080,
0x00C0C0C0,
0x00808080,
0x00FF0000,
0x0000FF00,
0x00FFFF00,
0x000000FF,
0x00FF00FF,
0x0000FFFF,
0x00ffffff
};
//
// tile screen
//
{
RECT rect;
HBITMAP hbmCars = LoadBitmap(hInstMain,MAKEINTRESOURCE(CAR_BITMAP));
LOGBRUSH lgBrush;
HBRUSH hbrFill;
lgBrush.lbStyle = BS_PATTERN;
lgBrush.lbColor = 0;
lgBrush.lbHatch = (LONG)hbmCars;
hbrFill = CreateBrushIndirect(&lgBrush);
GetClientRect(pCallData->hwnd,&rect);
FillTransformedRect(hdc,&rect,hbrFill);
DeleteObject(hbrFill);
DeleteObject(hbmCars);
}
//
// init drawing modes
//
SetStretchBltMode(hdc,HALFTONE);
SetGraphicsMode(hdc,GM_ADVANCED);
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
//
// select and realize palette
//
hpal = CreateHtPalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pbih = (PBITMAPINFOHEADER)&pbmi->bmiHeader;
pulColors = (PULONG)&pbmi->bmiColors[0];
pbih->biSize = sizeof(BITMAPINFOHEADER);
pbih->biWidth = 512;
pbih->biHeight = 256;
pbih->biPlanes = 1;
pbih->biBitCount = 4;
pbih->biCompression = BI_RGB;
pbih->biSizeImage = 0;
pbih->biXPelsPerMeter = 0;
pbih->biYPelsPerMeter = 0;
pbih->biClrUsed = 0;
pbih->biClrImportant = 0;
memcpy(pulColors,&ulVGA[0],16*4);
hdib4 = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib4,NULL,0);
SelectObject(hdcm4,hdib4);
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0xff00;
vert[1].x = 100;
vert[1].y = 100;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0xff00;
PatBlt(hdcm4,0,0,128,128,BLACKNESS);
GradientFill(hdcm4,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_H);
BitBlt(hdc,0,0,128,128,hdcm4,0,0,SRCCOPY);
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0xff00;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0xff00;
vert[1].x = 100;
vert[1].y = 100;
vert[1].Red = 0x0000;
vert[1].Green = 0xff00;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0xff00;
PatBlt(hdcm4,0,0,128,128,BLACKNESS);
GradientFill(hdcm4,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_H);
BitBlt(hdc,0,128+10,128,128,hdcm4,0,0,SRCCOPY);
//
// triangle
//
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0x0000;
vert[1].x = 100;
vert[1].y = 0;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0x0000;
vert[2].x = 100;
vert[2].y = 100;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
vert[3].x = 100;
vert[3].y = 10;
vert[3].Red = 0x0000;
vert[3].Green = 0xff00;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
vert[4].x = 100;
vert[4].y = 110;
vert[4].Red = 0x0000;
vert[4].Green = 0xff00;
vert[4].Blue = 0x0000;
vert[4].Alpha = 0x0000;
vert[5].x = 0;
vert[5].y = 110;
vert[5].Red = 0x0000;
vert[5].Green = 0xff00;
vert[5].Blue = 0x0000;
vert[5].Alpha = 0x0000;
PatBlt(hdcm4,0,0,128,128,BLACKNESS);
GradientFill(hdcm4,vert,6,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
BitBlt(hdc,200,0,128,128,hdcm4,0,0,SRCCOPY);
//
// r,g,b,grey gradient
//
{
GRADIENT_TRIANGLE gradTri[8] = {
{ 0, 1, 2},{ 1, 2, 3},
{ 4, 5, 6},{ 5, 6, 7},
{ 8, 9,10},{ 9,10,11},
{12,13,14},{13,14,15}
};
int dy = 64;
// clear
PatBlt(hdcm4,0,0,1000,1000,BLACKNESS);
// Blue
vert[0].x = 0;
vert[0].y = dy * 0;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0x0000;
vert[1].x = 512;
vert[1].y = dy * 0;0;
vert[1].Red = 0x0000;
vert[1].Green = 0x0000;
vert[1].Blue = 0x0000;
vert[1].Alpha = 0x0000;
vert[2].x = 0;
vert[2].y = dy * 0 + (dy-4);
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
vert[3].x = 512;
vert[3].y = dy * 0 + (dy-4);
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
// red
vert[4].x = 0;
vert[4].y = dy * 1;
vert[4].Red = 0xff00;
vert[4].Green = 0x0000;
vert[4].Blue = 0x0000;
vert[4].Alpha = 0x0000;
vert[5].x = 512;
vert[5].y = dy * 1;
vert[5].Red = 0x0000;
vert[5].Green = 0x0000;
vert[5].Blue = 0x0000;
vert[5].Alpha = 0x0000;
vert[6].x = 0;
vert[6].y = dy * 1 + (dy-4);
vert[6].Red = 0xff00;
vert[6].Green = 0x0000;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0x0000;
vert[7].x = 512;
vert[7].y = dy * 1 + (dy-4);
vert[7].Red = 0x0000;
vert[7].Green = 0x0000;
vert[7].Blue = 0x0000;
vert[7].Alpha = 0x0000;
// green
vert[8].x = 0;
vert[8].y = dy * 2;
vert[8].Red = 0x0000;
vert[8].Green = 0xff00;
vert[8].Blue = 0x0000;
vert[8].Alpha = 0x0000;
vert[9].x = 512;
vert[9].y = dy * 2;
vert[9].Red = 0x0000;
vert[9].Green = 0x0000;
vert[9].Blue = 0x0000;
vert[9].Alpha = 0x0000;
vert[10].x = 0;
vert[10].y = dy * 2 + (dy-4);
vert[10].Red = 0x0000;
vert[10].Green = 0xff00;
vert[10].Blue = 0x0000;
vert[10].Alpha = 0x0000;
vert[11].x = 512;
vert[11].y = dy * 2 + (dy-4);
vert[11].Red = 0x0000;
vert[11].Green = 0x0000;
vert[11].Blue = 0x0000;
vert[11].Alpha = 0x0000;
// grey
vert[12].x = 0;
vert[12].y = dy * 3;
vert[12].Red = 0xff00;
vert[12].Green = 0xff00;
vert[12].Blue = 0xff00;
vert[12].Alpha = 0x0000;
vert[13].x = 512;
vert[13].y = dy * 3;
vert[13].Red = 0x0000;
vert[13].Green = 0x0000;
vert[13].Blue = 0x0000;
vert[13].Alpha = 0x0000;
vert[14].x = 0;
vert[14].y = dy * 3 + (dy-4);
vert[14].Red = 0xff00;
vert[14].Green = 0xff00;
vert[14].Blue = 0xff00;
vert[14].Alpha = 0x0000;
vert[15].x = 512;
vert[15].y = dy * 3 + (dy-4);
vert[15].Red = 0x0000;
vert[15].Green = 0x0000;
vert[15].Blue = 0x0000;
vert[15].Alpha = 0x0000;
GradientFill(hdcm4,vert,16,(PVOID)gradTri,8,GRADIENT_FILL_TRIANGLE);
BitBlt(hdc,200,128+10,512,256,hdcm4,0,0,SRCCOPY);
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
DeleteDC(hdcm4);
DeleteObject(hdib4);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestGradRect1(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_RECT gRect[2] = {{0,1},{2,3}};
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{3,4,5}};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm1 = CreateCompatibleDC(hdc);
HBITMAP hdib1;
PBYTE pDib1;
PBITMAPINFO pbmi;
PBITMAPINFOHEADER pbih;
ULONG ux,uy;
PULONG pulColors;
ULONG ulVGA[] = {
0x00000000,
0x00ffffff,
0x00008000,
0x00808000,
0x00000080,
0x00800080,
0x00008080,
0x00C0C0C0,
0x00808080,
0x00FF0000,
0x0000FF00,
0x00FFFF00,
0x000000FF,
0x00FF00FF,
0x0000FFFF,
0x00ffffff
};
//
// tile screen
//
{
RECT rect;
HBITMAP hbmCars = LoadBitmap(hInstMain,MAKEINTRESOURCE(CAR_BITMAP));
LOGBRUSH lgBrush;
HBRUSH hbrFill;
lgBrush.lbStyle = BS_PATTERN;
lgBrush.lbColor = 0;
lgBrush.lbHatch = (LONG)hbmCars;
hbrFill = CreateBrushIndirect(&lgBrush);
GetClientRect(pCallData->hwnd,&rect);
FillTransformedRect(hdc,&rect,hbrFill);
DeleteObject(hbrFill);
DeleteObject(hbmCars);
}
//
// init drawing modes
//
SetStretchBltMode(hdc,HALFTONE);
SetGraphicsMode(hdc,GM_ADVANCED);
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
//
// select and realize palette
//
hpal = CreateHtPalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pbih = (PBITMAPINFOHEADER)&pbmi->bmiHeader;
pulColors = (PULONG)&pbmi->bmiColors[0];
pbih->biSize = sizeof(BITMAPINFOHEADER);
pbih->biWidth = 128;
pbih->biHeight = 128;
pbih->biPlanes = 1;
pbih->biBitCount = 1;
pbih->biCompression = BI_RGB;
pbih->biSizeImage = 0;
pbih->biXPelsPerMeter = 0;
pbih->biYPelsPerMeter = 0;
pbih->biClrUsed = 0;
pbih->biClrImportant = 0;
memcpy(pulColors,&ulVGA[0],2*4);
hdib1 = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib1,NULL,0);
SelectObject(hdcm1,hdib1);
PatBlt(hdcm1,0,0,128,128,BLACKNESS);
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0xff00;
vert[1].x = 100;
vert[1].y = 100;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0xff00;
GradientFill(hdcm1,vert,2,(PVOID)gRect,1,GRADIENT_FILL_RECT_H);
BitBlt(hdc,0,0,128,128,hdcm1,0,0,SRCCOPY);
PatBlt(hdcm1,0,0,128,128,BLACKNESS);
//
// triangle
//
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0xff00;
vert[0].Green = 0xff00;
vert[0].Blue = 0xff00;
vert[0].Alpha = 0x0000;
vert[1].x = 100;
vert[1].y = 0;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0x0000;
vert[2].x = 100;
vert[2].y = 100;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
GradientFill(hdcm1,vert,3,(PVOID)gTri,1,GRADIENT_FILL_TRIANGLE);
BitBlt(hdc,200,0,128,128,hdcm1,0,0,SRCCOPY);
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
DeleteDC(hdcm1);
DeleteObject(hdib1);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
LONG
GEN_RAND_VERT(
LONG Limit
)
{
LONG l1 = rand() & 0xffff;
LONG l2 = rand() & 0xffff;
l1 = (l1 << 16) | l2;
l1 = l1 % Limit;
return(l1);
}
VOID
vTestRandTri(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[4] = {{0,1,2},{0,2,3},{0,3,4},{0,4,5}};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
HBITMAP hdib;
PBYTE pDib;
SetStretchBltMode(hdc,HALFTONE);
SetGraphicsMode(hdc,GM_ADVANCED);
//
// clear screen
//
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
FillTransformedRect(hdc,&rect,(HBRUSH)GetStockObject(BLACK_BRUSH));
//
// select and realize palette
//
hpal = CreateHalftonePalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = rect.right;
pbmi->bmiHeader.biHeight = -200;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 32;
pbmi->bmiHeader.biCompression = BI_RGB;
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)
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
}
srand(11);
LONG MaxVert1 = 0xffffffff;
LONG MaxVert2 = 0x000007ff;
LONG vIndex = 0;
LONG MaxVert = MaxVert2;
//#define GEN_RAND_VERT(v) ((((rand() & 0xffff) << 16) | (rand() & 0xffff)) & v - (v/2))
do
{
vIndex++;
if (vIndex > 100)
{
vIndex = 0;
if (MaxVert == MaxVert1)
{
MaxVert = MaxVert2;
}
else
{
MaxVert = MaxVert1;
}
}
vert[0].x = GEN_RAND_VERT(MaxVert);
vert[0].y = GEN_RAND_VERT(MaxVert);
vert[0].Red = rand() & 0xffff;
vert[0].Green = rand() & 0xffff;
vert[0].Blue = rand() & 0xffff;
vert[0].Alpha = rand() & 0xffff;
vert[1].x = -vert[0].x;
vert[1].y = -vert[0].y;
vert[1].Red = rand() & 0xffff;
vert[1].Green = rand() & 0xffff;
vert[1].Blue = rand() & 0xffff;
vert[1].Alpha = rand() & 0xffff;
vert[2].x = GEN_RAND_VERT(MaxVert);
vert[2].y = GEN_RAND_VERT(MaxVert);
vert[2].Red = rand() & 0xffff;
vert[2].Green = rand() & 0xffff;
vert[2].Blue = rand() & 0xffff;
vert[2].Alpha = rand() & 0xffff;
vert[3].x = GEN_RAND_VERT(MaxVert);
vert[3].y = GEN_RAND_VERT(MaxVert);
vert[3].Red = rand() & 0xffff;
vert[3].Green = rand() & 0xffff;
vert[3].Blue = rand() & 0xffff;
vert[3].Alpha = rand() & 0xffff;
vert[4].x = GEN_RAND_VERT(MaxVert);
vert[4].y = GEN_RAND_VERT(MaxVert);
vert[4].Red = rand() & 0xffff;
vert[4].Green = rand() & 0xffff;
vert[4].Blue = rand() & 0xffff;
vert[4].Alpha = rand() & 0xffff;
vert[5].x = GEN_RAND_VERT(MaxVert);
vert[5].y = GEN_RAND_VERT(MaxVert);
vert[5].Red = rand() & 0xffff;
vert[5].Green = rand() & 0xffff;
vert[5].Blue = rand() & 0xffff;
vert[5].Alpha = rand() & 0xffff;
GradientFill(hdc,vert,6,(PVOID)gTri,4,GRADIENT_FILL_TRIANGLE);
#if 0
DbgPrint("vTestRandTri:\n\n");
DbgPrint("vTestRandTri:vert[0].x = %li \n",vert[0].x);
DbgPrint("vTestRandTri:vert[0].y = %li \n",vert[0].y);
DbgPrint("vTestRandTri:vert[0].Red = %li \n",vert[0].Red);
DbgPrint("vTestRandTri:vert[0].Green = %li \n",vert[0].Green);
DbgPrint("vTestRandTri:vert[0].Blue = %li \n",vert[0].Blue);
DbgPrint("vTestRandTri:vert[0].Alpha = %li \n",vert[0].Alpha);
DbgPrint("vTestRandTri:vert[1].x = %li \n",vert[1].x);
DbgPrint("vTestRandTri:vert[1].y = %li \n",vert[1].y);
DbgPrint("vTestRandTri:vert[1].Red = %li \n",vert[1].Red);
DbgPrint("vTestRandTri:vert[1].Green = %li \n",vert[1].Green);
DbgPrint("vTestRandTri:vert[1].Blue = %li \n",vert[1].Blue);
DbgPrint("vTestRandTri:vert[1].Alpha = %li \n",vert[1].Alpha);
DbgPrint("vTestRandTri:vert[2].x = %li \n",vert[2].x);
DbgPrint("vTestRandTri:vert[2].y = %li \n",vert[2].y);
DbgPrint("vTestRandTri:vert[2].Red = %li \n",vert[2].Red);
DbgPrint("vTestRandTri:vert[2].Green = %li \n",vert[2].Green);
DbgPrint("vTestRandTri:vert[2].Blue = %li \n",vert[2].Blue);
DbgPrint("vTestRandTri:vert[2].Alpha = %li \n",vert[2].Alpha);
#endif
} while (TRUE);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteObject(hpal);
DeleteObject(hdib);
bThreadActive = FALSE;
}
TRIVERTEX gvert[3] = {
{
10,
10,
0,
0,
0,
0
},
{
1100,
10,
0xff00,
0,
0,
0
},
{
100,
100,
0,
0,
0,
0
}
};
BOOL
APIENTRY GetOptionDlgProc(
HWND hDlg,
unsigned message,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
Process message for about box, show a dialog box that says what the
name of the program is.
Arguments:
hDlg - window handle of the dialog box
message - type of message
wParam - message-specific information
lParam - message-specific information
Return Value:
status of operation
Revision History:
03-21-91 Initial code
--*/
{
CHAR msg[255];
CHAR EditTextInput[255];
ULONG i;
ULONG TmpInput;
switch (message) {
case WM_INITDIALOG:
wsprintf(msg,"%i",gvert[0].x);
SetDlgItemText(hDlg,IDD_TRI1_X,msg);
wsprintf(msg,"%i",gvert[0].y);
SetDlgItemText(hDlg,IDD_TRI1_Y,msg);
wsprintf(msg,"%i",gvert[0].Red/256);
SetDlgItemText(hDlg,IDD_TRI1_R,msg);
wsprintf(msg,"%i",gvert[0].Green/256);
SetDlgItemText(hDlg,IDD_TRI1_G,msg);
wsprintf(msg,"%i",gvert[0].Blue/256);
SetDlgItemText(hDlg,IDD_TRI1_B,msg);
wsprintf(msg,"%i",gvert[1].x);
SetDlgItemText(hDlg,IDD_TRI2_X,msg);
wsprintf(msg,"%i",gvert[1].y);
SetDlgItemText(hDlg,IDD_TRI2_Y,msg);
wsprintf(msg,"%i",gvert[1].Red/256);
SetDlgItemText(hDlg,IDD_TRI2_R,msg);
wsprintf(msg,"%i",gvert[1].Green/256);
SetDlgItemText(hDlg,IDD_TRI2_G,msg);
wsprintf(msg,"%i",gvert[1].Blue/256);
SetDlgItemText(hDlg,IDD_TRI2_B,msg);
wsprintf(msg,"%i",gvert[2].x);
SetDlgItemText(hDlg,IDD_TRI3_X,msg);
wsprintf(msg,"%i",gvert[2].y);
SetDlgItemText(hDlg,IDD_TRI3_Y,msg);
wsprintf(msg,"%i",gvert[2].Red/256);
SetDlgItemText(hDlg,IDD_TRI3_R,msg);
wsprintf(msg,"%i",gvert[2].Green/256);
SetDlgItemText(hDlg,IDD_TRI3_G,msg);
wsprintf(msg,"%i",gvert[2].Blue/256);
SetDlgItemText(hDlg,IDD_TRI3_B,msg);
return (TRUE);
case WM_COMMAND:
switch(wParam) {
//
// end function
//
case IDOK:
{
ULONG ix;
for (ix = IDD_TRI1_X;ix <= IDD_TRI3_B;ix++)
{
GetDlgItemText(hDlg,ix,EditTextInput,20);
i = sscanf(EditTextInput,"%i",&TmpInput);
if (i == 1)
{
switch (ix)
{
case IDD_TRI1_X:
gvert[0].x = TmpInput;
break;
case IDD_TRI1_Y:
gvert[0].y = TmpInput;
break;
case IDD_TRI1_R:
gvert[0].Red = TmpInput * 256;
break;
case IDD_TRI1_G:
gvert[0].Green = TmpInput * 256;
break;
case IDD_TRI1_B:
gvert[0].Blue = TmpInput * 256;
break;
case IDD_TRI2_X:
gvert[1].x = TmpInput;
break;
case IDD_TRI2_Y:
gvert[1].y = TmpInput;
break;
case IDD_TRI2_R:
gvert[1].Red = TmpInput * 256;
break;
case IDD_TRI2_G:
gvert[1].Green = TmpInput * 256;
break;
case IDD_TRI2_B:
gvert[1].Blue = TmpInput * 256;
break;
case IDD_TRI3_X:
gvert[2].x = TmpInput;
break;
case IDD_TRI3_Y:
gvert[2].y = TmpInput;
break;
case IDD_TRI3_R:
gvert[2].Red = TmpInput * 256;
break;
case IDD_TRI3_G:
gvert[2].Green = TmpInput * 256;
break;
case IDD_TRI3_B:
gvert[2].Blue = TmpInput * 256;
break;
}
}
}
}
EndDialog(hDlg, TRUE);
return (TRUE);
case IDCANCEL:
EndDialog(hDlg, FALSE);
return (TRUE);
//
// change text
//
case IDD_TRI1_X:
case IDD_TRI1_Y:
case IDD_TRI1_R:
case IDD_TRI1_G:
case IDD_TRI1_B:
case IDD_TRI2_X:
case IDD_TRI2_Y:
case IDD_TRI2_R:
case IDD_TRI2_G:
case IDD_TRI2_B:
case IDD_TRI3_X:
case IDD_TRI3_Y:
case IDD_TRI3_R:
case IDD_TRI3_G:
case IDD_TRI3_B:
if (HIWORD(lParam) == EN_CHANGE)
{
EnableWindow(GetDlgItem(hDlg,IDOK),
(BOOL)SendMessage((HWND)(LOWORD(lParam)),
WM_GETTEXTLENGTH,
0,
0L));
}
return(TRUE);
}
break;
}
return (FALSE);
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestInputTri(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{3,4,5}};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
HBITMAP hdib;
PBYTE pDib;
SetStretchBltMode(hdc,HALFTONE);
SetGraphicsMode(hdc,GM_ADVANCED);
//
// clear screen
//
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
FillTransformedRect(hdc,&rect,(HBRUSH)GetStockObject(BLACK_BRUSH));
DialogBox(hInstMain, (LPSTR)IDD_TRIANGLE_DLG, pCallData->hwnd, (DLGPROC)GetOptionDlgProc);
//
// select and realize palette
//
hpal = CreateHalftonePalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = rect.right;
pbmi->bmiHeader.biHeight = -200;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 32;
pbmi->bmiHeader.biCompression = BI_RGB;
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)
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
}
#if 0
vert[0].x = 174 ;
vert[0].y = 10023 ;
vert[0].Red = 4365 ;
vert[0].Green = 18055 ;
vert[0].Blue = 21674 ;
vert[0].Alpha = 12218 ;
vert[1].x = 5802 ;
vert[1].y = -835 ;
vert[1].Red = 19082 ;
vert[1].Green = 26799 ;
vert[1].Blue = 2609 ;
vert[1].Alpha = 9098 ;
vert[2].x = 17644 ;
vert[2].y = 60 ;
vert[2].Red = 4890 ;
vert[2].Green = 7222 ;
vert[2].Blue = 13531 ;
vert[2].Alpha = 7987 ;
vert[0].x = -16777216;
vert[0].y = 10;
vert[0].Red = 0;
vert[0].Green = 0;
vert[0].Blue = 0;
vert[0].Alpha = 0;
vert[1].x = 16777216;
vert[1].y = 10;
vert[1].Red = 0xff00;
vert[1].Green = 0;
vert[1].Blue = 0;
vert[1].Alpha = 0;
vert[2].x = -16777216;
vert[2].y = 20;
vert[2].Red = 0;
vert[2].Green = 0;
vert[2].Blue = 0;
vert[2].Alpha = 0;
#endif
GradientFill(hdc,gvert,3,(PVOID)gTri,1,GRADIENT_FILL_TRIANGLE);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteObject(hpal);
DeleteObject(hdib);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTriDIB32(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{0,2,3}};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
HBITMAP hdib;
PBYTE pDib;
SetStretchBltMode(hdc,COLORONCOLOR);
//
// clear screen
//
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
FillTransformedRect(hdc,&rect,(HBRUSH)GetStockObject(BLACK_BRUSH));
//
// select and realize palette
//
hpal = CreateHalftonePalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = rect.right;
pbmi->bmiHeader.biHeight = -200;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 32;
pbmi->bmiHeader.biCompression = BI_RGB;
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)
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
}
vert[0].x = 10;
vert[0].y = 10;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = 10;
vert[1].Red = 0xc000;
vert[1].Green = 0xc000;
vert[1].Blue = 0xc000;
vert[1].Alpha = 0xc000;
vert[2].x = rect.right-10;
vert[2].y = 30;
vert[2].Red = 0xc000;
vert[2].Green = 0xc000;
vert[2].Blue = 0xc000;
vert[2].Alpha = 0xc000;
vert[3].x = 10;
vert[3].y = 30;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
GradientFill(hdcm,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
vert[0].x = 10;
vert[0].y = 40;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x6000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = 40;
vert[1].Red = 0x0000;
vert[1].Green = 0x6000;
vert[1].Blue = 0xf000;
vert[1].Alpha = 0x0000;
vert[2].x = rect.right-10;
vert[2].y = 200-10;
vert[2].Red = 0x0000;
vert[2].Green = 0x6000;
vert[2].Blue = 0xf000;
vert[2].Alpha = 0xf000;
vert[3].x = 10;
vert[3].y = 200-10;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x6000;
vert[3].Alpha = 0x0000;
GradientFill(hdcm,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,0,0,rect.right,200,hdcm,0,0,rect.right,200,SRCCOPY);
LocalFree(pbmi);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteObject(hpal);
DeleteObject(hdib);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTriDIB8Halftone(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[8] = {{0,1,2},{0,2,3},
{4,5,6},{4,6,7},
{8,9,10},{8,10,11},
{12,13,14},{12,14,15}
};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
HDC hdcm32 = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
PULONG pulColors;
LPPALETTEENTRY pePalette;
HBITMAP hdib,hdib32;
PBYTE pDib,pDib32;
ULONG ulIndex;
HBRUSH hbr = CreateSolidBrush(PALETTERGB(128,128,128));
SetStretchBltMode(hdc,COLORONCOLOR);
//
// get screen dimensions
//
GetClientRect(pCallData->hwnd,&rect);
//
// dib dimensions are screen in x and 1/2 screen in y
//
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom/2;
//
// select and realize palette
//
hpal = CreateHalftonePalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
SelectPalette(hdcm,hpal,TRUE);
RealizePalette(hdcm);
SelectPalette(hdcm32,hpal,TRUE);
RealizePalette(hdcm32);
//
// fill background
//
FillTransformedRect(hdc,&rect,hbr);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pulColors = (PULONG)&pbmi->bmiColors[0];
pePalette = (LPPALETTEENTRY)pulColors;
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = dibRect.right;
pbmi->bmiHeader.biHeight = -dibRect.bottom;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 8;
pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 0;
pbmi->bmiHeader.biClrImportant = 0;
GetPaletteEntries(hpal,0,256,pePalette);
for (ulIndex=0;ulIndex<256;ulIndex++)
{
BYTE temp = pePalette[ulIndex].peRed;
pePalette[ulIndex].peRed = pePalette[ulIndex].peBlue;
pePalette[ulIndex].peBlue = temp;
}
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
pbmi->bmiHeader.biBitCount = 32;
hdib32 = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib32,NULL,0);
if ((hdib == NULL) || (hdib32 == NULL))
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
if (SelectObject(hdcm32,hdib32) == NULL)
{
MessageBox(NULL,"error selecting 32 bpp DIB","Error",MB_OK);
}
}
//
// init DIBs
//
FillTransformedRect(hdcm,&dibRect,hbr);
FillTransformedRect(hdcm32,&dibRect,hbr);
//
// draw grey scale and r,g and b scales
//
{
LONG ScaleHeight = (dibRect.bottom -50)/4;
LONG ypos = 10;
//
// grey
//
vert[0].x = 10;
vert[0].y = ypos;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = ypos;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0x0000;
vert[2].x = rect.right-10;
vert[2].y = ypos + ScaleHeight;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
vert[3].x = 10;
vert[3].y = ypos + ScaleHeight;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
//
// red
//
vert[4].x = 10;
vert[4].y = ypos;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0x0000;
vert[4].Alpha = 0x0000;
vert[5].x = rect.right-10;
vert[5].y = ypos;
vert[5].Red = 0xff00;
vert[5].Green = 0x0000;
vert[5].Blue = 0x0000;
vert[5].Alpha = 0x0000;
vert[6].x = rect.right-10;
vert[6].y = ypos + ScaleHeight;
vert[6].Red = 0xff00;
vert[6].Green = 0x0000;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0x0000;
vert[7].x = 10;
vert[7].y = ypos + ScaleHeight;
vert[7].Red = 0x0000;
vert[7].Green = 0x0000;
vert[7].Blue = 0x0000;
vert[7].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[8].x = 10;
vert[8].y = ypos;
vert[8].Red = 0x0000;
vert[8].Green = 0x0000;
vert[8].Blue = 0x0000;
vert[8].Alpha = 0x0000;
vert[9].x = rect.right-10;
vert[9].y = ypos;
vert[9].Red = 0x0000;
vert[9].Green = 0xff00;
vert[9].Blue = 0x0000;
vert[9].Alpha = 0x0000;
vert[10].x = rect.right-10;
vert[10].y = ypos + ScaleHeight;
vert[10].Red = 0x0000;
vert[10].Green = 0xff00;
vert[10].Blue = 0x0000;
vert[10].Alpha = 0x0000;
vert[11].x = 10;
vert[11].y = ypos + ScaleHeight;
vert[11].Red = 0x0000;
vert[11].Green = 0x0000;
vert[11].Blue = 0x0000;
vert[11].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[12].x = 10;
vert[12].y = ypos;
vert[12].Red = 0x0000;
vert[12].Green = 0x0000;
vert[12].Blue = 0x0000;
vert[12].Alpha = 0x0000;
vert[13].x = rect.right-10;
vert[13].y = ypos;
vert[13].Red = 0x0000;
vert[13].Green = 0x0000;
vert[13].Blue = 0xff00;
vert[13].Alpha = 0x0000;
vert[14].x = rect.right-10;
vert[14].y = ypos + ScaleHeight;
vert[14].Red = 0x0000;
vert[14].Green = 0x0000;
vert[14].Blue = 0xff00;
vert[14].Alpha = 0x0000;
vert[15].x = 10;
vert[15].y = ypos + ScaleHeight;
vert[15].Red = 0x0000;
vert[15].Green = 0x0000;
vert[15].Blue = 0x0000;
vert[15].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
GradientFill(hdcm ,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcm32,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,0,0,rect.right,dibRect.bottom,hdcm,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,HALFTONE);
StretchBlt(hdc,0,dibRect.bottom,rect.right,dibRect.bottom,hdcm32,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,COLORONCOLOR);
}
DeleteObject(hbr);
LocalFree(pbmi);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteDC(hdcm32);
DeleteObject(hpal);
DeleteObject(hdib);
DeleteObject(hdib32);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTriDIB8DefPal(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[8] = {{0,1,2},{0,2,3},
{4,5,6},{4,6,7},
{8,9,10},{8,10,11},
{12,13,14},{12,14,15}
};
TRIVERTEX vert[32];
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
HDC hdcm32 = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
PULONG pulColors;
LPPALETTEENTRY pePalette;
HBITMAP hdib,hdib32;
PBYTE pDib,pDib32;
ULONG ulIndex;
HBRUSH hbr = CreateSolidBrush(PALETTERGB(128,128,128));
SetStretchBltMode(hdc,COLORONCOLOR);
//
// get screen dimensions
//
GetClientRect(pCallData->hwnd,&rect);
//
// dib dimensions are screen in x and 1/2 screen in y
//
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom/2;
//
// fill background
//
FillTransformedRect(hdc,&rect,hbr);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
if (pbmi)
{
pulColors = (PULONG)&pbmi->bmiColors[0];
pePalette = (LPPALETTEENTRY)pulColors;
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = dibRect.right;
pbmi->bmiHeader.biHeight = -dibRect.bottom;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 8;
pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 16;
pbmi->bmiHeader.biClrImportant = 0;
UINT uiRet = GetPaletteEntries((HPALETTE)GetStockObject(DEFAULT_PALETTE),0,16,pePalette);
if (uiRet == 16)
{
for (ulIndex=0;ulIndex<16;ulIndex++)
{
BYTE temp = pePalette[ulIndex].peRed;
pePalette[ulIndex].peRed = pePalette[ulIndex].peBlue;
pePalette[ulIndex].peBlue = temp;
}
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
pbmi->bmiHeader.biBitCount = 32;
hdib32 = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib32,NULL,0);
if ((hdib == NULL) || (hdib32 == NULL))
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
if (SelectObject(hdcm32,hdib32) == NULL)
{
MessageBox(NULL,"error selecting 32 bpp DIB","Error",MB_OK);
}
}
//
// init DIBs
//
FillTransformedRect(hdcm,&dibRect,hbr);
FillTransformedRect(hdcm32,&dibRect,hbr);
//
// draw grey scale and r,g and b scales
//
{
LONG ScaleHeight = (dibRect.bottom -50)/4;
LONG ypos = 10;
//
// grey
//
vert[0].x = 10;
vert[0].y = ypos;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = ypos;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0x0000;
vert[2].x = rect.right-10;
vert[2].y = ypos + ScaleHeight;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
vert[3].x = 10;
vert[3].y = ypos + ScaleHeight;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
//
// red
//
vert[4].x = 10;
vert[4].y = ypos;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0x0000;
vert[4].Alpha = 0x0000;
vert[5].x = rect.right-10;
vert[5].y = ypos;
vert[5].Red = 0xff00;
vert[5].Green = 0x0000;
vert[5].Blue = 0x0000;
vert[5].Alpha = 0x0000;
vert[6].x = rect.right-10;
vert[6].y = ypos + ScaleHeight;
vert[6].Red = 0xff00;
vert[6].Green = 0x0000;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0x0000;
vert[7].x = 10;
vert[7].y = ypos + ScaleHeight;
vert[7].Red = 0x0000;
vert[7].Green = 0x0000;
vert[7].Blue = 0x0000;
vert[7].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[8].x = 10;
vert[8].y = ypos;
vert[8].Red = 0x0000;
vert[8].Green = 0x0000;
vert[8].Blue = 0x0000;
vert[8].Alpha = 0x0000;
vert[9].x = rect.right-10;
vert[9].y = ypos;
vert[9].Red = 0x0000;
vert[9].Green = 0xff00;
vert[9].Blue = 0x0000;
vert[9].Alpha = 0x0000;
vert[10].x = rect.right-10;
vert[10].y = ypos + ScaleHeight;
vert[10].Red = 0x0000;
vert[10].Green = 0xff00;
vert[10].Blue = 0x0000;
vert[10].Alpha = 0x0000;
vert[11].x = 10;
vert[11].y = ypos + ScaleHeight;
vert[11].Red = 0x0000;
vert[11].Green = 0x0000;
vert[11].Blue = 0x0000;
vert[11].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[12].x = 10;
vert[12].y = ypos;
vert[12].Red = 0x0000;
vert[12].Green = 0x0000;
vert[12].Blue = 0x0000;
vert[12].Alpha = 0x0000;
vert[13].x = rect.right-10;
vert[13].y = ypos;
vert[13].Red = 0x0000;
vert[13].Green = 0x0000;
vert[13].Blue = 0xff00;
vert[13].Alpha = 0x0000;
vert[14].x = rect.right-10;
vert[14].y = ypos + ScaleHeight;
vert[14].Red = 0x0000;
vert[14].Green = 0x0000;
vert[14].Blue = 0xff00;
vert[14].Alpha = 0x0000;
vert[15].x = 10;
vert[15].y = ypos + ScaleHeight;
vert[15].Red = 0x0000;
vert[15].Green = 0x0000;
vert[15].Blue = 0x0000;
vert[15].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
GradientFill(hdcm ,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcm32,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,0,0,rect.right,dibRect.bottom,hdcm,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,HALFTONE);
StretchBlt(hdc,0,dibRect.bottom,rect.right,dibRect.bottom,hdcm32,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,COLORONCOLOR);
}
}
LocalFree(pbmi);
}
DeleteObject(hbr);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteDC(hdcm32);
DeleteObject(hdib);
DeleteObject(hdib32);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTriDIB4(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[8] = {{0,1,2},{0,2,3},
{4,5,6},{4,6,7},
{8,9,10},{8,10,11},
{12,13,14},{12,14,15}
};
TRIVERTEX vert[32];
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
HDC hdcm32 = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
PULONG pulColors;
LPPALETTEENTRY pePalette;
HBITMAP hdib,hdib32;
PBYTE pDib,pDib32;
ULONG ulIndex;
HBRUSH hbr = CreateSolidBrush(PALETTERGB(128,128,128));
SetStretchBltMode(hdc,COLORONCOLOR);
//
// get screen dimensions
//
GetClientRect(pCallData->hwnd,&rect);
//
// dib dimensions are screen in x and 1/2 screen in y
//
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom/2;
//
// fill background
//
FillTransformedRect(hdc,&rect,hbr);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pulColors = (PULONG)&pbmi->bmiColors[0];
pePalette = (LPPALETTEENTRY)pulColors;
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = dibRect.right;
pbmi->bmiHeader.biHeight = -dibRect.bottom;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 4;
pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 0;
pbmi->bmiHeader.biClrImportant = 0;
GetSystemPaletteEntries(hdc,0,256,pePalette);
for (ulIndex=0;ulIndex<8;ulIndex++)
{
BYTE temp = pePalette[ulIndex].peRed;
pePalette[ulIndex].peRed = pePalette[ulIndex].peBlue;
pePalette[ulIndex].peBlue = temp;
pePalette[8 + ulIndex].peGreen = pePalette[255-ulIndex].peGreen;
pePalette[8 + ulIndex].peRed = pePalette[255-ulIndex].peBlue;
pePalette[8 + ulIndex].peBlue = pePalette[255-ulIndex].peRed;
}
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
pbmi->bmiHeader.biBitCount = 32;
hdib32 = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib32,NULL,0);
if ((hdib == NULL) || (hdib32 == NULL))
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
if (SelectObject(hdcm32,hdib32) == NULL)
{
MessageBox(NULL,"error selecting 32 bpp DIB","Error",MB_OK);
}
}
//
// init DIBs
//
FillTransformedRect(hdcm,&dibRect,hbr);
FillTransformedRect(hdcm32,&dibRect,hbr);
//
// draw grey scale and r,g and b scales
//
{
LONG ScaleHeight = (dibRect.bottom -50)/4;
LONG ypos = 10;
//
// grey
//
vert[0].x = 10;
vert[0].y = ypos;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = ypos;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0x0000;
vert[2].x = rect.right-10;
vert[2].y = ypos + ScaleHeight;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
vert[3].x = 10;
vert[3].y = ypos + ScaleHeight;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
//
// red
//
vert[4].x = 10;
vert[4].y = ypos;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0x0000;
vert[4].Alpha = 0x0000;
vert[5].x = rect.right-10;
vert[5].y = ypos;
vert[5].Red = 0xff00;
vert[5].Green = 0x0000;
vert[5].Blue = 0x0000;
vert[5].Alpha = 0x0000;
vert[6].x = rect.right-10;
vert[6].y = ypos + ScaleHeight;
vert[6].Red = 0xff00;
vert[6].Green = 0x0000;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0x0000;
vert[7].x = 10;
vert[7].y = ypos + ScaleHeight;
vert[7].Red = 0x0000;
vert[7].Green = 0x0000;
vert[7].Blue = 0x0000;
vert[7].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[8].x = 10;
vert[8].y = ypos;
vert[8].Red = 0x0000;
vert[8].Green = 0x0000;
vert[8].Blue = 0x0000;
vert[8].Alpha = 0x0000;
vert[9].x = rect.right-10;
vert[9].y = ypos;
vert[9].Red = 0x0000;
vert[9].Green = 0xff00;
vert[9].Blue = 0x0000;
vert[9].Alpha = 0x0000;
vert[10].x = rect.right-10;
vert[10].y = ypos + ScaleHeight;
vert[10].Red = 0x0000;
vert[10].Green = 0xff00;
vert[10].Blue = 0x0000;
vert[10].Alpha = 0x0000;
vert[11].x = 10;
vert[11].y = ypos + ScaleHeight;
vert[11].Red = 0x0000;
vert[11].Green = 0x0000;
vert[11].Blue = 0x0000;
vert[11].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[12].x = 10;
vert[12].y = ypos;
vert[12].Red = 0x0000;
vert[12].Green = 0x0000;
vert[12].Blue = 0x0000;
vert[12].Alpha = 0x0000;
vert[13].x = rect.right-10;
vert[13].y = ypos;
vert[13].Red = 0x0000;
vert[13].Green = 0x0000;
vert[13].Blue = 0xff00;
vert[13].Alpha = 0x0000;
vert[14].x = rect.right-10;
vert[14].y = ypos + ScaleHeight;
vert[14].Red = 0x0000;
vert[14].Green = 0x0000;
vert[14].Blue = 0xff00;
vert[14].Alpha = 0x0000;
vert[15].x = 10;
vert[15].y = ypos + ScaleHeight;
vert[15].Red = 0x0000;
vert[15].Green = 0x0000;
vert[15].Blue = 0x0000;
vert[15].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
GradientFill(hdcm ,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcm32,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,0,0,rect.right,dibRect.bottom,hdcm,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,HALFTONE);
StretchBlt(hdc,0,dibRect.bottom,rect.right,dibRect.bottom,hdcm32,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,COLORONCOLOR);
}
DeleteObject(hbr);
LocalFree(pbmi);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteDC(hdcm32);
DeleteObject(hdib);
DeleteObject(hdib32);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTriDIB1(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[8] = {{0,1,2},{0,2,3},
{4,5,6},{4,6,7},
{8,9,10},{8,10,11},
{12,13,14},{12,14,15}
};
TRIVERTEX vert[32];
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
HDC hdcm32 = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
PULONG pulColors;
LPPALETTEENTRY pePalette;
HBITMAP hdib,hdib32;
PBYTE pDib,pDib32;
ULONG ulIndex;
HBRUSH hbr = CreateSolidBrush(PALETTERGB(128,128,128));
SetStretchBltMode(hdc,COLORONCOLOR);
//
// get screen dimensions
//
GetClientRect(pCallData->hwnd,&rect);
//
// dib dimensions are screen in x and 1/2 screen in y
//
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom/2;
//
// fill background
//
FillTransformedRect(hdc,&rect,hbr);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pulColors = (PULONG)&pbmi->bmiColors[0];
pePalette = (LPPALETTEENTRY)pulColors;
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = dibRect.right;
pbmi->bmiHeader.biHeight = -dibRect.bottom;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 1;
pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 0;
pbmi->bmiHeader.biClrImportant = 0;
pePalette[0].peGreen = 0x00;
pePalette[0].peRed = 0x00;
pePalette[0].peBlue = 0x00;
pePalette[0].peFlags = 0x00;
pePalette[1].peGreen = 0xff;
pePalette[1].peRed = 0xff;
pePalette[1].peBlue = 0xff;
pePalette[1].peFlags = 0x00;
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
pbmi->bmiHeader.biBitCount = 32;
hdib32 = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib32,NULL,0);
if ((hdib == NULL) || (hdib32 == NULL))
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
if (SelectObject(hdcm32,hdib32) == NULL)
{
MessageBox(NULL,"error selecting 32 bpp DIB","Error",MB_OK);
}
}
//
// init DIBs
//
FillTransformedRect(hdcm,&dibRect,hbr);
FillTransformedRect(hdcm32,&dibRect,hbr);
//
// draw grey scale and r,g and b scales
//
{
LONG ScaleHeight = (dibRect.bottom -50)/4;
LONG ypos = 10;
//
// grey
//
vert[0].x = 10;
vert[0].y = ypos;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = ypos;
vert[1].Red = 0xff00;
vert[1].Green = 0xff00;
vert[1].Blue = 0xff00;
vert[1].Alpha = 0x0000;
vert[2].x = rect.right-10;
vert[2].y = ypos + ScaleHeight;
vert[2].Red = 0xff00;
vert[2].Green = 0xff00;
vert[2].Blue = 0xff00;
vert[2].Alpha = 0x0000;
vert[3].x = 10;
vert[3].y = ypos + ScaleHeight;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
//
// red
//
vert[4].x = 10;
vert[4].y = ypos;
vert[4].Red = 0x0000;
vert[4].Green = 0x0000;
vert[4].Blue = 0x0000;
vert[4].Alpha = 0x0000;
vert[5].x = rect.right-10;
vert[5].y = ypos;
vert[5].Red = 0xff00;
vert[5].Green = 0xff00;
vert[5].Blue = 0x0000;
vert[5].Alpha = 0x0000;
vert[6].x = rect.right-10;
vert[6].y = ypos + ScaleHeight;
vert[6].Red = 0xff00;
vert[6].Green = 0xff00;
vert[6].Blue = 0x0000;
vert[6].Alpha = 0x0000;
vert[7].x = 10;
vert[7].y = ypos + ScaleHeight;
vert[7].Red = 0x0000;
vert[7].Green = 0x0000;
vert[7].Blue = 0x0000;
vert[7].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[8].x = 10;
vert[8].y = ypos;
vert[8].Red = 0x0000;
vert[8].Green = 0x0000;
vert[8].Blue = 0x0000;
vert[8].Alpha = 0x0000;
vert[9].x = rect.right-10;
vert[9].y = ypos;
vert[9].Red = 0x0000;
vert[9].Green = 0xff00;
vert[9].Blue = 0x0000;
vert[9].Alpha = 0x0000;
vert[10].x = rect.right-10;
vert[10].y = ypos + ScaleHeight;
vert[10].Red = 0x0000;
vert[10].Green = 0xff00;
vert[10].Blue = 0x0000;
vert[10].Alpha = 0x0000;
vert[11].x = 10;
vert[11].y = ypos + ScaleHeight;
vert[11].Red = 0x0000;
vert[11].Green = 0x0000;
vert[11].Blue = 0x0000;
vert[11].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
vert[12].x = 10;
vert[12].y = ypos;
vert[12].Red = 0x0000;
vert[12].Green = 0x0000;
vert[12].Blue = 0x0000;
vert[12].Alpha = 0x0000;
vert[13].x = rect.right-10;
vert[13].y = ypos;
vert[13].Red = 0x0000;
vert[13].Green = 0x0000;
vert[13].Blue = 0xff00;
vert[13].Alpha = 0x0000;
vert[14].x = rect.right-10;
vert[14].y = ypos + ScaleHeight;
vert[14].Red = 0x0000;
vert[14].Green = 0x0000;
vert[14].Blue = 0xff00;
vert[14].Alpha = 0x0000;
vert[15].x = 10;
vert[15].y = ypos + ScaleHeight;
vert[15].Red = 0x0000;
vert[15].Green = 0x0000;
vert[15].Blue = 0x0000;
vert[15].Alpha = 0x0000;
ypos += (10 + ScaleHeight);
GradientFill(hdcm ,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcm32,vert,16,(PVOID)gTri,8,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,0,0,rect.right,dibRect.bottom,hdcm,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,HALFTONE);
StretchBlt(hdc,0,dibRect.bottom,rect.right,dibRect.bottom,hdcm32,0,0,rect.right,dibRect.bottom,SRCCOPY);
SetStretchBltMode(hdc,COLORONCOLOR);
}
DeleteObject(hbr);
LocalFree(pbmi);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteDC(hdcm32);
DeleteObject(hdib);
DeleteObject(hdib32);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTriDIB16565(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{0,2,3}};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
HBITMAP hdib;
PBYTE pDib;
SetStretchBltMode(hdc,COLORONCOLOR);
//
// clear screen
//
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
FillTransformedRect(hdc,&rect,(HBRUSH)GetStockObject(BLACK_BRUSH));
//
// select and realize palette
//
hpal = CreateHalftonePalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 3 * sizeof(ULONG));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = rect.right;
pbmi->bmiHeader.biHeight = -200;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 16;
pbmi->bmiHeader.biCompression = BI_BITFIELDS;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 0;
pbmi->bmiHeader.biClrImportant = 0;
{
PULONG pbitfields = (PULONG)&pbmi->bmiColors[0];
pbitfields[0] = 0xf800;
pbitfields[1] = 0x07e0;
pbitfields[2] = 0x001f;
}
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
if (hdib == NULL)
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
}
vert[0].x = 10;
vert[0].y = 10;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = 10;
vert[1].Red = 0xc000;
vert[1].Green = 0xc000;
vert[1].Blue = 0xc000;
vert[1].Alpha = 0xc000;
vert[2].x = rect.right-10;
vert[2].y = 30;
vert[2].Red = 0xc000;
vert[2].Green = 0xc000;
vert[2].Blue = 0xc000;
vert[2].Alpha = 0xc000;
vert[3].x = 10;
vert[3].y = 30;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
GradientFill(hdcm,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
vert[0].x = 10;
vert[0].y = 40;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x6000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = 40;
vert[1].Red = 0x0000;
vert[1].Green = 0x6000;
vert[1].Blue = 0xf000;
vert[1].Alpha = 0x0000;
vert[2].x = rect.right-10;
vert[2].y = 200-10;
vert[2].Red = 0x0000;
vert[2].Green = 0x6000;
vert[2].Blue = 0xf000;
vert[2].Alpha = 0xf000;
vert[3].x = 10;
vert[3].y = 200-10;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x6000;
vert[3].Alpha = 0x0000;
GradientFill(hdcm,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,0,0,rect.right,200,hdcm,0,0,rect.right,200,SRCCOPY);
LocalFree(pbmi);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteObject(hpal);
DeleteObject(hdib);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 18-Jul-1996 -by- Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestTriDIB16555(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{0,2,3}};
TRIVERTEX vert[32];
HPALETTE hpal;
RECT rect;
RECT dibRect;
HDC hdcm = CreateCompatibleDC(hdc);
PBITMAPINFO pbmi;
HBITMAP hdib;
PBYTE pDib;
SetStretchBltMode(hdc,COLORONCOLOR);
SetGraphicsMode(hdc,GM_ADVANCED);
//
// clear screen
//
GetClientRect(pCallData->hwnd,&rect);
dibRect.left = 0;
dibRect.right = rect.right;
dibRect.top = 0;
dibRect.bottom = rect.bottom;
FillTransformedRect(hdc,&rect,(HBRUSH)GetStockObject(BLACK_BRUSH));
//
// select and realize palette
//
hpal = CreateHalftonePalette(hdc);
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// create temp DIB
//
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 3 * sizeof(ULONG));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = rect.right;
pbmi->bmiHeader.biHeight = -200;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 16;
pbmi->bmiHeader.biCompression = BI_BITFIELDS;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 0;
pbmi->bmiHeader.biClrImportant = 0;
{
PULONG pbitfields = (PULONG)&pbmi->bmiColors[0];
pbitfields[0] = 0x7c00;
pbitfields[1] = 0x03e0;
pbitfields[2] = 0x001f;
}
hdib = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDib,NULL,0);
if (hdib == NULL)
{
MessageBox(NULL,"error Creating DIB","Error",MB_OK);
}
else
{
if (SelectObject(hdcm,hdib) == NULL)
{
MessageBox(NULL,"error selecting DIB","Error",MB_OK);
}
}
vert[0].x = 10;
vert[0].y = 10;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x0000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = 10;
vert[1].Red = 0xc000;
vert[1].Green = 0xc000;
vert[1].Blue = 0xc000;
vert[1].Alpha = 0xc000;
vert[2].x = rect.right-10;
vert[2].y = 30;
vert[2].Red = 0xc000;
vert[2].Green = 0xc000;
vert[2].Blue = 0xc000;
vert[2].Alpha = 0xc000;
vert[3].x = 10;
vert[3].y = 30;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x0000;
vert[3].Alpha = 0x0000;
GradientFill(hdcm,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
vert[0].x = 10;
vert[0].y = 40;
vert[0].Red = 0x0000;
vert[0].Green = 0x0000;
vert[0].Blue = 0x6000;
vert[0].Alpha = 0x0000;
vert[1].x = rect.right-10;
vert[1].y = 40;
vert[1].Red = 0x0000;
vert[1].Green = 0x6000;
vert[1].Blue = 0xf000;
vert[1].Alpha = 0x0000;
vert[2].x = rect.right-10;
vert[2].y = 200-10;
vert[2].Red = 0x0000;
vert[2].Green = 0x6000;
vert[2].Blue = 0xf000;
vert[2].Alpha = 0xf000;
vert[3].x = 10;
vert[3].y = 200-10;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0x6000;
vert[3].Alpha = 0x0000;
GradientFill(hdcm,vert,4,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
StretchBlt(hdc,0,0,rect.right,200,hdcm,0,0,rect.right,200,SRCCOPY);
LocalFree(pbmi);
ReleaseDC(pCallData->hwnd,hdc);
DeleteDC(hdcm);
DeleteObject(hpal);
DeleteObject(hdib);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
* vDrawMetafile
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 9/19/1996 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vDrawMetafile(
HDC hdc,
HDC hdcm
)
{
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{0,2,3}};
TRIVERTEX vert[4];
//
// draw using alpha and shading APIs
//
vert[0].x = 10;
vert[0].y = 10;
vert[0].Red = 0x4000;
vert[0].Green = 0x8000;
vert[0].Blue = 0xc000;
vert[0].Alpha = 0xff00;
vert[1].x = 390;
vert[1].y = 10;
vert[1].Red = 0xc000;
vert[1].Green = 0x8000;
vert[1].Blue = 0x4000;
vert[1].Alpha = 0xff00;
vert[2].x = 390;
vert[2].y = 390;
vert[2].Red = 0x0000;
vert[2].Green = 0x0000;
vert[2].Blue = 0x0000;
vert[2].Alpha = 0xff00;
vert[3].x = 10;
vert[3].y = 390;
vert[3].Red = 0x0000;
vert[3].Green = 0x0000;
vert[3].Blue = 0xff00;
vert[3].Alpha = 0xff00;
PatBlt(hdcm,000,000,400,400,BLACKNESS);
GradientFill(hdcm,vert,6,(PVOID)gTri,2,GRADIENT_FILL_TRIANGLE);
//
// alpha blending
//
{
PBITMAPINFO pbmi;
HBITMAP hdibA;
HDC hdcA = CreateCompatibleDC(hdc);
PULONG pDibA;
BLENDFUNCTION BlendFunction;
pbmi = (PBITMAPINFO)LocalAlloc(0,sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = 128;
pbmi->bmiHeader.biHeight = -128;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = 32;
pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 0;
pbmi->bmiHeader.biClrImportant = 0;
hdibA = CreateDIBSection(hdc,pbmi,DIB_RGB_COLORS,(VOID **)&pDibA,NULL,0);
BlendFunction.BlendOp = AC_SRC_OVER;
BlendFunction.BlendFlags = 0;
BlendFunction.SourceConstantAlpha = 128;
//
// init 32 bpp dib
//
{
PULONG ptmp = pDibA;
ULONG ux,uy;
for (uy=0;uy<128;uy++)
{
for (ux=0;ux<128;ux++)
{
BYTE blue = (ux*2);
BYTE green = (uy*2);
BYTE red = 0;
BYTE alpha = 0xff;
*ptmp++ = (alpha << 24) | (red << 16) | (green << 8) | (blue);
}
}
*((PULONG)pDibA) = 0x80800000;
ptmp = (PULONG)((PBYTE)pDibA + 32 * (128 *4));
for (uy=32;uy<42;uy++)
{
for (ux=0;ux<128;ux++)
{
*ptmp++ = 0x80800000;
}
}
}
HPALETTE hpal = CreateHalftonePalette(hdc);
SelectObject(hdcA,hdibA);
HPALETTE hpalOld = SelectPalette(hdcm,hpal,FALSE);
SelectPalette(hdcA,hpal,FALSE);
RealizePalette(hdcm);
RealizePalette(hdcA);
AlphaBlend(hdcm,100,100,128,128,hdcA, 0,0,128,128,BlendFunction);
BitBlt(hdcm,100,250,128,128,hdcA,0,0,SRCCOPY);
AlphaBlend(hdcm,250,250,128,128,hdcA, 0,0,128,128,BlendFunction);
{
RECT rcl = {10,60,100,100};
DrawTextExW(hdcm,L"Fred",4,&rcl,0,NULL);
}
DeleteDC(hdcA);
DeleteObject(hdibA);
SelectPalette(hdcm,hpalOld,TRUE);
DeleteObject(hpal);
LocalFree(pbmi);
}
}
/******************************Public*Routine******************************\
* vCreateMetaFile
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 9/19/1996 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vCreateMetaFile(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HDC hdcm;
RECT rcl;
ULONG ypos = 0;
ULONG xpos = 0;
LPCTSTR lpFilename = "MetaBlend.EMF";
LPCTSTR lpDescription = "Alpha Blending test metafile";
GetClientRect(pCallData->hwnd,&rcl);
FillTransformedRect(hdc,&rcl,(HBRUSH)GetStockObject(GRAY_BRUSH));
SetTextColor(hdc,0);
SetBkMode(hdc,TRANSPARENT);
//
// Create metafile DC
//
hdcm = CreateEnhMetaFile(hdc,lpFilename,NULL,lpDescription);
if (hdcm != NULL)
{
vDrawMetafile(hdc,hdcm);
vDrawMetafile(hdc,hdc);
{
HENHMETAFILE hemf = CloseEnhMetaFile(hdcm);
if (hemf)
{
PCHAR pstr = "Metafile creation successful";
DeleteEnhMetaFile(hemf);
TextOut(hdc,10,10,pstr,strlen(pstr));
}
else
{
MessageBox(NULL,"Error closing metafile","Error",MB_OK);
}
}
}
else
{
MessageBox(NULL,"Error creating metafile","Error",MB_OK);
}
ReleaseDC(pCallData->hwnd,hdc);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
* vPlayMetaFile
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 12/4/1996 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vPlayMetaFile(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
RECT rcl;
ULONG ypos = 0;
ULONG xpos = 0;
LPCTSTR lpFilename = "MetaBlend.EMF";
LPCTSTR lpDescription = "Alpha Blending test metafile";
HENHMETAFILE hemf;
GetClientRect(pCallData->hwnd,&rcl);
FillTransformedRect(hdc,&rcl,(HBRUSH)GetStockObject(GRAY_BRUSH));
SetTextColor(hdc,0);
SetBkMode(hdc,TRANSPARENT);
hemf = GetEnhMetaFile(lpFilename);
if (hemf)
{
rcl.left = 0;
rcl.top = 0;
rcl.right = 16;
rcl.bottom = 16;
PlayEnhMetaFile(hdc,hemf,&rcl);
rcl.left = 16;
rcl.top = 16;
rcl.right = 80;
rcl.bottom = 80;
PlayEnhMetaFile(hdc,hemf,&rcl);
rcl.left = 100;
rcl.top = 0;
rcl.right = 500;
rcl.bottom = 400;
PlayEnhMetaFile(hdc,hemf,&rcl);
DeleteEnhMetaFile(hemf);
}
ReleaseDC(pCallData->hwnd,hdc);
bThreadActive = FALSE;
}
/******************************Public*Routine******************************\
* vTestRASDD
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 9/19/1996 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestRASDD(
TEST_CALL_DATA *pCallData
)
{
HDC hdcScreen = GetDCAndTransform(pCallData->hwnd);
HDC hdcPrn;
RECT rcl;
ULONG ypos = 0;
ULONG xpos = 0;
LPCTSTR lpPrinterName = "HP Color";
DOCINFO docInfo = {sizeof(DOCINFO),
"Doc1",
NULL
};
hdcPrn = CreateDC(NULL,lpPrinterName,NULL,NULL);
if (hdcPrn == NULL)
{
MessageBox(NULL,"Couldn't create DC",lpPrinterName,MB_OK);
}
else
{
LONG iJobID = StartDoc(hdcPrn,&docInfo);
if (iJobID == SP_ERROR)
{
MessageBox(NULL,"StartDoc fails","error",MB_OK);
}
else
{
LONG iRet = StartPage(hdcPrn);
if (iRet == SP_ERROR)
{
MessageBox(NULL,"StartPage fails","error",MB_OK);
}
else
{
ULONG ulIndex = 0;
HBITMAP hbmPrn1 = hCreateAlphaStretchBitmap(hdcPrn,ulBpp[ulIndex],ulFor[ulIndex],600,600);
HDC hdcPrnMem1 = CreateCompatibleDC(hdcPrn);
HBITMAP hbmPrn2 = hCreateAlphaStretchBitmap(hdcPrn,ulBpp[ulIndex],ulFor[ulIndex],600,600);
HDC hdcPrnMem2 = CreateCompatibleDC(hdcPrn);
HBITMAP hbm1 = CreateCompatibleBitmap(hdcScreen,600,600);
HDC hdcScreenMem = CreateCompatibleDC(hdcScreen);
GRADIENT_TRIANGLE gTri[2] = {{0,1,2},{3,4,5}};
GRADIENT_RECT gRect[2] = {{0,1},{2,3}};
TRIVERTEX vert[6];
//
// draw using alpha and shading APIs
//
POINT pos = {300,300};
double fr = 300.0;
double fTheta = 0.0;
double fdTheta = 0.05;
SelectObject(hdcPrnMem1,hbmPrn1);
SelectObject(hdcPrnMem2,hbmPrn2);
SelectObject(hdcScreenMem,hbm1);
PatBlt(hdcPrnMem1,0,0,5000,5000,0xff0000);
PatBlt(hdcPrnMem2,0,0,5000,5000,0xff0000);
PatBlt(hdcScreenMem,0,0,5000,5000,0xff0000);
PatBlt(hdcScreen,0,0,5000,5000,0xff0000);
PatBlt(hdcPrn,0,0,5000,5000,0xff0000);
//
// fill visible area with gradient
//
vert[0].x = 0;
vert[0].y = 0;
vert[0].Red = 0x8000;
vert[0].Green = 0x8000;
vert[0].Blue = 0x8000;
vert[0].Alpha = 0x0000;
vert[1].x = 900;
vert[1].y = 900;
vert[1].Red = 0xc000;
vert[1].Green = 0xc000;
vert[1].Blue = 0xc000;
vert[1].Alpha = 0x0000;
GradientFill(hdcScreen ,vert,2,&gRect,1,GRADIENT_FILL_RECT_V);
GradientFill(hdcPrn ,vert,2,&gRect,1,GRADIENT_FILL_RECT_V);
GradientFill(hdcPrnMem1 ,vert,2,&gRect,1,GRADIENT_FILL_RECT_V);
GradientFill(hdcPrnMem2 ,vert,2,&gRect,1,GRADIENT_FILL_RECT_V);
GradientFill(hdcScreenMem,vert,2,&gRect,1,GRADIENT_FILL_RECT_V);
vert[0].x = 200;
vert[0].y = 200;
vert[0].Red = 0x1000;
vert[0].Green = 0x1000;
vert[0].Blue = 0x1000;
vert[0].Alpha = 0x0000;
vert[1].x = 300;
vert[1].y = 700;
vert[1].Red = 0x2000;
vert[1].Green = 0x2000;
vert[1].Blue = 0x2000;
vert[1].Alpha = 0x0000;
vert[2].x = 140;
vert[2].y = 420;
vert[2].Red = 0x1500;
vert[2].Green = 0x1500;
vert[2].Blue = 0x1500;
vert[2].Alpha = 0x0000;
vert[3].x = 200;
vert[3].y = 200;
vert[3].Red = 0x1000;
vert[3].Green = 0x1000;
vert[3].Blue = 0x1000;
vert[3].Alpha = 0x0000;
vert[4].x = 100;
vert[4].y = 700;
vert[4].Red = 0x2000;
vert[4].Green = 0x2000;
vert[4].Blue = 0x2000;
vert[4].Alpha = 0x0000;
vert[5].x = 260;
vert[5].y = 420;
vert[5].Red = 0x1500;
vert[5].Green = 0x1500;
vert[5].Blue = 0x1500;
vert[5].Alpha = 0x0000;
GradientFill(hdcScreen,vert,6,&gTri,2,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcPrn,vert,6,&gTri,2,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcPrnMem1,vert,6,&gTri,2,GRADIENT_FILL_TRIANGLE);
Sleep(2000);
//
// draw gradient circle in memory
//
vert[0].x = pos.x;
vert[0].y = pos.y;
vert[0].Red = 0x6000;
vert[0].Green = 0x6000;
vert[0].Blue = 0x6000;
vert[0].Alpha = 0x0000;
vert[1].Red = 0xcf00;
vert[1].Green = 0xcf00;
vert[1].Blue = 0xcf00;
vert[1].Alpha = 0x0000;
vert[2].Red = 0xcf00;
vert[2].Green = 0xcf00;
vert[2].Blue = 0xcf00;
vert[2].Alpha = 0x0000;
fTheta = 0;
double fLimit = (2.0 * fdTheta) * 4.0;
while (fTheta < (2.0 * 3.14159265))
{
vert[0].x = pos.x;
vert[0].y = pos.y;
vert[1].x = (LONG)(pos.x + fr * cos(fTheta));
vert[1].y = (LONG)(pos.y + fr * sin(fTheta));
fTheta += fdTheta;
vert[2].x = (LONG)(pos.x + fr * cos(fTheta));
vert[2].y = (LONG)(pos.y + fr * sin(fTheta));
GradientFill(hdcPrnMem2 ,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
GradientFill(hdcScreenMem,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
vert[0].x *= 2;
vert[0].y = 2 * vert[0].y + 2000;
vert[1].x *= 2;
vert[1].y = 2 * vert[1].y + 2000;
vert[2].x *= 2;
vert[2].y = 2 * vert[2].y + 2000;
GradientFill(hdcPrn,vert,3,&gTri,1,GRADIENT_FILL_TRIANGLE);
}
//
// blend alpha over data (0/1 in 1bpp)
//
{
BLENDFUNCTION BlendFunction;
BlendFunction.BlendOp = AC_SRC_OVER;
BlendFunction.BlendFlags = 0;
BlendFunction.AlphaFormat = 0;
//
// blend printer data
//
SetStretchBltMode(hdcScreen,HALFTONE);
SetStretchBltMode(hdcPrn,HALFTONE);
BlendFunction.SourceConstantAlpha = 0x10;
AlphaBlend(hdcPrnMem1,0,0,600,600,hdcPrnMem2,0,0,600,600,BlendFunction);
StretchBlt(hdcPrn,1000,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
Sleep(1000);
BlendFunction.SourceConstantAlpha = 0x40;
AlphaBlend(hdcPrnMem1,0,0,600,600,hdcPrnMem2,0,0,600,600,BlendFunction);
StretchBlt(hdcPrn,2000,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
Sleep(1000);
BlendFunction.SourceConstantAlpha = 0x70;
AlphaBlend(hdcPrnMem1,0,0,600,600,hdcPrnMem2,0,0,600,600,BlendFunction);
StretchBlt(hdcPrn,3000,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
Sleep(1000);
BlendFunction.SourceConstantAlpha = 0xa0;
AlphaBlend(hdcPrnMem1,0,0,600,600,hdcPrnMem2,0,0,600,600,BlendFunction);
StretchBlt(hdcPrn,4000,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
Sleep(1000);
BlendFunction.SourceConstantAlpha = 0xc0;
AlphaBlend(hdcPrnMem1,0,0,600,600,hdcPrnMem2,0,0,600,600,BlendFunction);
StretchBlt(hdcPrn,0000,1000,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
Sleep(1000);
BlendFunction.SourceConstantAlpha = 0xe0;
AlphaBlend(hdcPrnMem1,0,0,600,600,hdcPrnMem2,0,0,600,600,BlendFunction);
StretchBlt(hdcPrn,1000,1000,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
Sleep(1000);
BlendFunction.SourceConstantAlpha = 0xfe;
AlphaBlend(hdcPrnMem1,0,0,600,600,hdcPrnMem2,0,0,600,600,BlendFunction);
StretchBlt(hdcPrn,2000,1000,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem1,0,0,900,900,SRCCOPY);
Sleep(1000);
StretchBlt(hdcPrn,30000,1000,900,900,hdcPrnMem2,0,0,900,900,SRCCOPY);
StretchBlt(hdcScreen,0,0,900,900,hdcPrnMem2,0,0,900,900,SRCCOPY);
}
DeleteDC(hdcPrnMem1);
DeleteDC(hdcPrnMem2);
DeleteObject(hbmPrn1);
DeleteObject(hbmPrn2);
DeleteDC(hdcScreenMem);
DeleteObject(hbm1);
EndPage(hdcPrn);
}
EndDoc(hdcPrn);
}
DeleteDC(hdcPrn);
}
ReleaseDC(pCallData->hwnd,hdcScreen);
bThreadActive = FALSE;
}
VOID
vTestTranPrint(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HDC hdcm;
RECT rcl;
ULONG ypos = 0;
ULONG xpos = 0;
LPCTSTR lpPrinterName = "HP Color";
DOCINFO docInfo = {sizeof(DOCINFO),
"Doc1",
NULL
};
hdcm = CreateDC(NULL,lpPrinterName,NULL,NULL);
if (hdcm == NULL)
{
MessageBox(NULL,"Couldn't create DC",lpPrinterName,MB_OK);
}
else
{
LONG iJobID = StartDoc(hdcm,&docInfo);
if (iJobID == SP_ERROR)
{
MessageBox(NULL,"StartDoc fails","error",MB_OK);
}
else
{
LONG iRet = StartPage(hdcm);
if (iRet == SP_ERROR)
{
MessageBox(NULL,"StartPage fails","error",MB_OK);
}
else
{
HBITMAP hbm = LoadBitmap (hInstMain, MAKEINTRESOURCE(MONITOR_BITMAP));
HDC hdcPrnMem2 = CreateCompatibleDC(hdcm);
BitBlt (hdcm, 0, 0, 184, 170, hdcPrnMem2, 0, 0, SRCCOPY);
SelectObject(hdcPrnMem2,hbm);
DeleteDC(hdcPrnMem2);
DeleteObject(hbm);
EndPage(hdcm);
}
EndDoc(hdcm);
}
DeleteDC(hdcm);
}
ReleaseDC(pCallData->hwnd,hdc);
bThreadActive = FALSE;
}
/**************************************************************************\
* 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;
RECT rect;
SelectObject(hdc,hTestFont);
//
// Clear screen
//
SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdc,0,0,2000,2000,PATCOPY);
SelectObject(hdc,hbrFillCars);
//
// create mem dc, select test DIBSection
//
ULONG ux,uy;
ULONG dibx,diby;
PULONG pDib;
HDC hdcm = CreateCompatibleDC(hdc);
//
// display over black
//
hpal = CreateHtPalette(hdc);
SelectObject(hdcm,hdib);
SelectObject(hdcm,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdcm,0,0,2000,2000,PATCOPY);
HPALETTE hpalOld = SelectPalette(hdc,hpal,FALSE);
SelectPalette(hdcm,hpal,FALSE);
RealizePalette(hdc);
RealizePalette(hdcm);
SetTextColor(hdc,RGB(255,255,255));
SetBkMode(hdc,TRANSPARENT);
GRADIENT_RECT gRect = {0,1};
TRIVERTEX vert[6];
//
// 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);
HBRUSH hbrCyan = CreateSolidBrush(RGB(0,255,255));
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
//
LONG OffsetX = 0;
LONG 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);
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);
HRGN hrgn1 = CreateEllipticRgn(10,10,246,246);
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(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
CHAR Title[256];
CHAR NewTitle[256];
GetWindowText(pCallData->hwnd,Title,256);
//
// repeat for each src format
//
ULONG ulIndex = 0;
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
if (pCallData->Param != -1)
{
ulIndex = pCallData->Param;
HBITMAP hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],256,256);
if (hdib != NULL)
{
lstrcpy(NewTitle,Title);
lstrcat(NewTitle,pFormatStr[ulIndex]);
SetWindowText(pCallData->hwnd,NewTitle);
vRunGradRectHorz(hdc,hdib,GRADIENT_FILL_RECT_H);
DeleteObject(hdib);
}
}
else
{
while (ulBpp[ulIndex] != 0)
{
HBITMAP hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],256,256);
if (hdib != NULL)
{
lstrcpy(NewTitle,Title);
lstrcat(NewTitle,pFormatStr[ulIndex]);
SetWindowText(pCallData->hwnd,NewTitle);
vRunGradRectHorz(hdc,hdib,GRADIENT_FILL_RECT_H);
DeleteObject(hdib);
}
Sleep(gAlphaSleep);
ulIndex++;
}
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vTestGradVert
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestGradRectVert(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
CHAR Title[256];
CHAR NewTitle[256];
GetWindowText(pCallData->hwnd,Title,256);
ULONG ulIndex = 0;
SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);
//
// repeat for each src format
//
if (pCallData->Param != -1)
{
ulIndex = pCallData->Param;
HBITMAP hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],256,256);
if (hdib != NULL)
{
lstrcpy(NewTitle,Title);
lstrcat(NewTitle,pFormatStr[ulIndex]);
SetWindowText(pCallData->hwnd,NewTitle);
vRunGradRectHorz(hdc,hdib,GRADIENT_FILL_RECT_V);
DeleteObject(hdib);
}
}
else
{
while (ulBpp[ulIndex] != 0)
{
HBITMAP hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[ulIndex],ulFor[ulIndex],256,256);
if (hdib != NULL)
{
lstrcpy(NewTitle,Title);
lstrcat(NewTitle,pFormatStr[ulIndex]);
SetWindowText(pCallData->hwnd,NewTitle);
vRunGradRectHorz(hdc,hdib,GRADIENT_FILL_RECT_V);
DeleteObject(hdib);
}
Sleep(gAlphaSleep);
ulIndex++;
}
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vRunGradTriangle
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/17/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vRunGradTriangle(
HDC hdc,
HBITMAP hdib
)
{
ULONG xpos = 10;
ULONG ypos = 10;
ULONG dy = 10;
ULONG dx = 10;
HPALETTE hpal;
RECT rect;
SelectObject(hdc,hTestFont);
//
// Clear screen
//
SelectObject(hdc,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdc,0,0,2000,2000,PATCOPY);
SelectObject(hdc,hbrFillCars);
//
// create mem dc, select test DIBSection
//
ULONG ux,uy;
ULONG dibx,diby;
PULONG pDib;
HDC hdcm = CreateCompatibleDC(hdc);
//
// display over black
//
hpal = CreateHtPalette(hdc);
SelectObject(hdcm,hdib);
SelectObject(hdcm,GetStockObject(DKGRAY_BRUSH));
PatBlt(hdcm,0,0,2000,2000,PATCOPY);
HPALETTE hpalOld = SelectPalette(hdc,hpal,FALSE);
SelectPalette(hdcm,hpal,FALSE);
RealizePalette(hdc);
RealizePalette(hdcm);
SetTextColor(hdc,RGB(255,255,255));
SetBkMode(hdc,TRANSPARENT);
GRADIENT_TRIANGLE gTri[2] ={{0,1,2},{0,2,3}};
TRIVERTEX vert[6];
//
// 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);
HBRUSH hbrCyan = CreateSolidBrush(RGB(0,255,255));
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
//
LONG OffsetX = 0;
LONG 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);
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);
HRGN hrgn1 = CreateEllipticRgn(10,10,246,246);
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);
DeleteObject(hrgn1);
xpos = 16;
ypos += (256+16);
SelectPalette(hdc,hpalOld,TRUE);
BOOL bRet1 = DeleteObject(hdcm);
BOOL bRet2 = DeleteObject(hpal);
}
/**************************************************************************\
* vTestTriangle
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestGradTriangle(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
HPALETTE hpal = CreateHtPalette(hdc);
CHAR Title[256];
CHAR NewTitle[256];
GetWindowText(pCallData->hwnd,Title,256);
//
// repeat for each src format
//
if (pCallData->Param != -1)
{
HBITMAP hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[pCallData->Param],ulFor[pCallData->Param],256,256);
if (hdib != NULL)
{
lstrcpy(NewTitle,Title);
lstrcat(NewTitle,pFormatStr[pCallData->Param]);
SetWindowText(pCallData->hwnd,NewTitle);
vRunGradTriangle(hdc,hdib);
DeleteObject(hdib);
}
}
else
{
ULONG ulIndex = 0;
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]);
SetWindowText(pCallData->hwnd,NewTitle);
vRunGradTriangle(hdc,hdib);
DeleteObject(hdib);
}
Sleep(gAlphaSleep);
ulIndex++;
}
}
ReleaseDC(pCallData->hwnd,hdc);
DeleteObject(hpal);
}
/**************************************************************************\
* vTestCaps
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestCaps(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
CHAR Title[256];
CHAR NewTitle[256];
ULONG ShadeCaps = GetDeviceCaps(hdc,SHADEBLENDCAPS);
wsprintf(Title,"Caps = 0x%08lx",ShadeCaps);
TextOut(hdc,10,10,Title,strlen(Title));
ReleaseDC(pCallData->hwnd,hdc);
}
/**************************************************************************\
* vTestBrushOrg
*
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 4/11/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestBrushOrg(
TEST_CALL_DATA *pCallData
)
{
HDC hdc = GetDCAndTransform(pCallData->hwnd);
CHAR Title[256];
CHAR NewTitle[256];
PBYTE pPack = (PBYTE)LocalAlloc(0,sizeof(BITMAPINFO) + 8*8*4);
PBITMAPINFO pbmi = (PBITMAPINFO)pPack;
PBITMAPINFOHEADER pbmih = (PBITMAPINFOHEADER)&pbmi->bmiHeader;
PULONG pul = (PULONG)(pPack + sizeof(BITMAPINFO));
pbmih->biSize = sizeof(BITMAPINFOHEADER);
pbmih->biWidth = 8;
pbmih->biHeight = -8;
pbmih->biPlanes = 1;
pbmih->biBitCount = 32;
pbmih->biCompression = BI_RGB;
pbmih->biSizeImage = 0;
pbmih->biXPelsPerMeter = 0;
pbmih->biYPelsPerMeter = 0;
pbmih->biClrUsed = 0;
pbmih->biClrImportant = 0;
//
// init brush data
//
{
int ix,iy;
PULONG pulTmp = pul;
for (iy=0;iy<8;iy++)
{
for (ix=0;ix<8;ix++)
{
*pul++ = (((iy * (256/8)) << 16) | (ix * (256/8)));
//*pul++ = 0xffbb55;
}
}
}
HBITMAP hdib = hCreateAlphaStretchBitmap(hdc,ulBpp[0],ulFor[0],256,256);
HDC hdcm = CreateCompatibleDC(hdc);
SelectObject(hdcm,hdib);
HBRUSH hbr = CreateDIBPatternBrushPt(pPack,DIB_RGB_COLORS);
SelectObject(hdcm,hbr);
PatBlt(hdcm,0,0,64,64,0);
GdiFlush();
SetBrushOrgEx(hdcm,0,0,NULL);
GdiFlush();
PatBlt(hdcm,0,0,8,8,PATCOPY);
GdiFlush();
SetBrushOrgEx(hdcm,1,1,NULL);
GdiFlush();
PatBlt(hdcm,0,16,8,8,PATCOPY);
GdiFlush();
SetBrushOrgEx(hdcm,0,0,NULL);
GdiFlush();
PatBlt(hdcm,0,32,8,8,PATCOPY);
GdiFlush();
SetBrushOrgEx(hdcm,4,4,NULL);
GdiFlush();
PatBlt(hdcm,0,48,8,8,PATCOPY);
GdiFlush();
BitBlt(hdc,0,0,64,64,hdcm,0,0,SRCCOPY);
DeleteObject(hbr);
DeleteDC(hdcm);
DeleteObject(hdib);
ReleaseDC(pCallData->hwnd,hdc);
}
/**************************************************************************\
* vTestDummy
*
* used in menu for locations that should no do anything
*
* Arguments:
*
*
*
* Return Value:
*
*
*
* History:
*
* 6/3/1997 Mark Enstrom [marke]
*
\**************************************************************************/
VOID
vTestDummy(
TEST_CALL_DATA *pCallData
)
{
}
//
// TEST_ENTRY controls automatic menu generation
//
// [Menu Level, Test Param, Stress Enable, Test Name, Test Function Pointer]
//
// Menu Level
// used to autoamtically generate sub-menus.
// 1 = 1rst level menu
// -n = start n-level sub menu
// n = continue sub menu
//
// Test Param
// passed as parameter to test
//
//
// Stress Ensable
// if 1, test is run in stress mode
// if 0, test is not run (tests that require input or runforever)
//
//
// Test Name
// ascii test name for menu
//
// Test Function Pointer
// pfn
//
TEST_ENTRY gTestEntry[] = {
{ 1, 0,1,(PUCHAR)"vTestBrushOrg ", (PFN_DISP)vTestBrushOrg},
{ 1, 0,1,(PUCHAR)"vTestCaps ", (PFN_DISP)vTestCaps},
{ 1, 0,1,(PUCHAR)"vTestMenu ", (PFN_DISP)vTestMenu},
{ 1, 0,1,(PUCHAR)"vTestDiamond ", (PFN_DISP)vTestDiamond},
{-2, 0,1,(PUCHAR)"Test Circle Gradients ", (PFN_DISP)vTestDummy},
{ 2, 0,1,(PUCHAR)"vTestCircle1 ", (PFN_DISP)vTestCircle1},
{ 2, 0,1,(PUCHAR)"vTestCircle2 ", (PFN_DISP)vTestCircle2},
{ 2, 0,1,(PUCHAR)"vTestCircle3 ", (PFN_DISP)vTestCircle3},
{ 1, 0,1,(PUCHAR)"vTestOverflow ", (PFN_DISP)vTestOverflow},
{ 1, 0,1,(PUCHAR)"vTestTessel ", (PFN_DISP)vTestTessel},
{ 1, 0,1,(PUCHAR)"vTestTri ", (PFN_DISP)vTestTri },
{-2, 0,1,(PUCHAR)"Grad Rect Tests ", (PFN_DISP)vTestDummy },
{ 2, 0,1,(PUCHAR)"vTestGradRect1 ", (PFN_DISP)vTestGradRect1},
{ 2, 0,1,(PUCHAR)"vTestGradRect4 ", (PFN_DISP)vTestGradRect4},
{ 2, 0,1,(PUCHAR)"vTestGradRectH ", (PFN_DISP)vTestGradRectH},
{ 2, 0,1,(PUCHAR)"vTestGradRectV ", (PFN_DISP)vTestGradRectV},
{ 2, 0,1,(PUCHAR)"vTestGradMap ", (PFN_DISP)vTestGradMap},
{-2, 0,1,(PUCHAR)"Multi-Res Tests ", (PFN_DISP)vTestDummy},
{-3, 0,1,(PUCHAR)"Test Grad Triangle ", (PFN_DISP)vTestDummy},
{ 3, -1,0,(PUCHAR)"vTestGradTriangle All ", (PFN_DISP)vTestGradTriangle},
{ 3, 0,1,(PUCHAR)"vTestGradTriangle 32BGRA", (PFN_DISP)vTestGradTriangle},
{ 3, 1,1,(PUCHAR)"vTestGradTriangle 32RGB ", (PFN_DISP)vTestGradTriangle},
{ 3, 2,1,(PUCHAR)"vTestGradTriangle 32GRB ", (PFN_DISP)vTestGradTriangle},
{ 3, 3,1,(PUCHAR)"vTestGradTriangle 24 ", (PFN_DISP)vTestGradTriangle},
{ 3, 4,1,(PUCHAR)"vTestGradTriangle 16_555", (PFN_DISP)vTestGradTriangle},
{ 3, 5,1,(PUCHAR)"vTestGradTriangle 16_565", (PFN_DISP)vTestGradTriangle},
{ 3, 6,1,(PUCHAR)"vTestGradTriangle 16_664", (PFN_DISP)vTestGradTriangle},
{ 3, 7,1,(PUCHAR)"vTestGradTriangle 8 ", (PFN_DISP)vTestGradTriangle},
{ 3, 8,1,(PUCHAR)"vTestGradTriangle 4 ", (PFN_DISP)vTestGradTriangle},
{ 3, 9,1,(PUCHAR)"vTestGradTriangle 1 ", (PFN_DISP)vTestGradTriangle},
{-3, 0,1,(PUCHAR)"Test Grad Rect Horz ", (PFN_DISP)vTestDummy},
{ 3, -1,0,(PUCHAR)"vTestGradRectHorz All ", (PFN_DISP)vTestGradRectHorz},
{ 3, 0,1,(PUCHAR)"vTestGradRectHorz 32BGRA", (PFN_DISP)vTestGradRectHorz},
{ 3, 1,1,(PUCHAR)"vTestGradRectHorz 32RGB ", (PFN_DISP)vTestGradRectHorz},
{ 3, 2,1,(PUCHAR)"vTestGradRectHorz 32GRB ", (PFN_DISP)vTestGradRectHorz},
{ 3, 3,1,(PUCHAR)"vTestGradRectHorz 24 ", (PFN_DISP)vTestGradRectHorz},
{ 3, 4,1,(PUCHAR)"vTestGradRectHorz 16_555", (PFN_DISP)vTestGradRectHorz},
{ 3, 5,1,(PUCHAR)"vTestGradRectHorz 16_565", (PFN_DISP)vTestGradRectHorz},
{ 3, 6,1,(PUCHAR)"vTestGradRectHorz 16_664", (PFN_DISP)vTestGradRectHorz},
{ 3, 7,1,(PUCHAR)"vTestGradRectHorz 8 ", (PFN_DISP)vTestGradRectHorz},
{ 3, 8,1,(PUCHAR)"vTestGradRectHorz 4 ", (PFN_DISP)vTestGradRectHorz},
{ 3, 9,1,(PUCHAR)"vTestGradRectHorz 1 ", (PFN_DISP)vTestGradRectHorz},
{-3, 0,1,(PUCHAR)"Test Grad Rect Vert ", (PFN_DISP)vTestDummy},
{ 3, -1,0,(PUCHAR)"vTestGradRectVert All ", (PFN_DISP)vTestGradRectVert},
{ 3, 0,1,(PUCHAR)"vTestGradRectVert 32BGRA", (PFN_DISP)vTestGradRectVert},
{ 3, 1,1,(PUCHAR)"vTestGradRectVert 32RGB ", (PFN_DISP)vTestGradRectVert},
{ 3, 2,1,(PUCHAR)"vTestGradRectVert 32GRB ", (PFN_DISP)vTestGradRectVert},
{ 3, 3,1,(PUCHAR)"vTestGradRectVert 24 ", (PFN_DISP)vTestGradRectVert},
{ 3, 4,1,(PUCHAR)"vTestGradRectVert 16_555", (PFN_DISP)vTestGradRectVert},
{ 3, 5,1,(PUCHAR)"vTestGradRectVert 16_565", (PFN_DISP)vTestGradRectVert},
{ 3, 6,1,(PUCHAR)"vTestGradRectVert 16_664", (PFN_DISP)vTestGradRectVert},
{ 3, 7,1,(PUCHAR)"vTestGradRectVert 8 ", (PFN_DISP)vTestGradRectVert},
{ 3, 8,1,(PUCHAR)"vTestGradRectVert 4 ", (PFN_DISP)vTestGradRectVert},
{ 3, 9,1,(PUCHAR)"vTestGradRectVert 1 ", (PFN_DISP)vTestGradRectVert},
{-2, 0,1,(PUCHAR)"TRI DIB ", (PFN_DISP)vTestDummy },
{ 2, 0,1,(PUCHAR)"vTestTriDIB32 ", (PFN_DISP)vTestTriDIB32},
{ 2, 0,1,(PUCHAR)"vTestTriDIB16565 ", (PFN_DISP)vTestTriDIB16565},
{ 2, 0,1,(PUCHAR)"vTestTriDIB16555 ", (PFN_DISP)vTestTriDIB16555},
{ 2, 0,1,(PUCHAR)"vTestTriDIB8Halftone ", (PFN_DISP)vTestTriDIB8Halftone},
{ 2, 0,1,(PUCHAR)"vTestTriDIB8DefPal ", (PFN_DISP)vTestTriDIB8DefPal},
{-2, 0,1,(PUCHAR)"MetaFile ", (PFN_DISP)vTestDummy },
{ 2, 0,1,(PUCHAR)"vCreateMetaFile ", (PFN_DISP)vCreateMetaFile},
{ 2, 0,1,(PUCHAR)"vPlayMetaFile ", (PFN_DISP)vPlayMetaFile},
{-2, 0,0,(PUCHAR)"Printing ", (PFN_DISP)vTestDummy },
{ 2, 0,0,(PUCHAR)"vTestRASDD ", (PFN_DISP)vTestRASDD},
{ 2, 0,0,(PUCHAR)"vTestTranPrint ", (PFN_DISP)vTestTranPrint},
{ 1, 0,0,(PUCHAR)"vTestInputTri ", (PFN_DISP)vTestInputTri},
{ 1, 0,0,(PUCHAR)"vTestRandTri ", (PFN_DISP)vTestRandTri},
{-2, 0,0,(PUCHAR)"Test BltLnk Bug ", (PFN_DISP)vTestDummy},
{ 2, 0,0,(PUCHAR)"vTestBitBlt ", (PFN_DISP)vTestBitBlt},
{ 2, 0,0,(PUCHAR)"vTestBitBlt2 ", (PFN_DISP)vTestBitBlt2},
{ 2, 0,0,(PUCHAR)"vTestBitBlt3 ", (PFN_DISP)vTestBitBlt3},
{ 0, 0,1,(PUCHAR)" ", (PFN_DISP)vTestDummy}
};
ULONG gNumTests = sizeof(gTestEntry)/sizeof(TEST_ENTRY);