713 lines
19 KiB
C
713 lines
19 KiB
C
/******************************Module*Header*******************************\
|
|
* Module Name: ftpal.c
|
|
*
|
|
* Palette tests for NT.
|
|
*
|
|
* Created: 31-Aug-1991 15:35:03
|
|
* Author: Patrick Haluptzok patrickh
|
|
*
|
|
* Copyright (c) 1990 Microsoft Corporation
|
|
\**************************************************************************/
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
typedef struct _VGALOGPALETTE
|
|
{
|
|
USHORT ident;
|
|
USHORT NumEntries;
|
|
PALETTEENTRY palPalEntry[16];
|
|
} VGALOGPALETTE;
|
|
|
|
typedef struct _LOGPALETTE256
|
|
{
|
|
USHORT palVersion;
|
|
USHORT palNumEntries;
|
|
PALETTEENTRY palPalEntry[256];
|
|
} LOGPALETTE256;
|
|
|
|
VGALOGPALETTE logpalVGA =
|
|
{
|
|
0x300, // driver version
|
|
16, // num entries
|
|
{
|
|
{ 0, 0, 0, 0 }, // 0
|
|
{ 0x80,0, 0, 0 }, // 1
|
|
{ 0, 0x80,0, 0 }, // 2
|
|
{ 0x80,0x80,0, 0 }, // 3
|
|
{ 0, 0, 0x80,0 }, // 4
|
|
{ 0x80,0, 0x80,0 }, // 5
|
|
{ 0, 0x80,0x80,0 }, // 6
|
|
{ 0xC0,0xC0,0xC0,0 }, // 7
|
|
|
|
{ 0x80,0x80,0x80,0 }, // 8
|
|
{ 0xFF,0, 0, 0 }, // 9
|
|
{ 0, 0xFF,0, 0 }, // 10
|
|
{ 0xFF,0xFF,0, 0 }, // 11
|
|
{ 0, 0, 0xFF,0 }, // 12
|
|
{ 0xFF,0, 0xFF,0 }, // 13
|
|
{ 0, 0xFF,0xFF,0 }, // 14
|
|
{ 0xFF,0xFF,0xFF,0 } // 15
|
|
}
|
|
};
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vTestPal1
|
|
*
|
|
* Test GetNearestPaletteIndex
|
|
*
|
|
* History:
|
|
* 31-Aug-1991 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID vTestPal1(void)
|
|
{
|
|
HPALETTE hpal1;
|
|
UINT uiTemp;
|
|
|
|
hpal1 = CreatePalette((LPLOGPALETTE) &logpalVGA);
|
|
|
|
if (hpal1 == (HPALETTE) 0)
|
|
{
|
|
DbgPrint("vTestPal1 failed to create palette\n");
|
|
return;
|
|
}
|
|
|
|
AnimatePalette(hpal1, 0, 100, NULL);
|
|
SetPaletteEntries(hpal1, 0, 100, NULL);
|
|
|
|
uiTemp = GetNearestPaletteIndex(hpal1, 0);
|
|
|
|
if (uiTemp != 0)
|
|
DbgPrint("GetNearestPaletteIndex failed 0 %lx\n", uiTemp);
|
|
|
|
uiTemp = GetNearestPaletteIndex(hpal1, 0x00000080);
|
|
|
|
if (uiTemp != 1)
|
|
DbgPrint("GetNearestPaletteIndex failed 1 %lx\n", uiTemp);
|
|
|
|
uiTemp = GetNearestPaletteIndex(hpal1, 0x00C0C0C0);
|
|
|
|
if (uiTemp != 7)
|
|
DbgPrint("GetNearestPaletteIndex failed 7 %lx\n", uiTemp);
|
|
|
|
uiTemp = GetNearestPaletteIndex(hpal1, 0x0000FF00);
|
|
|
|
if (uiTemp != 10)
|
|
DbgPrint("GetNearestPaletteIndex failed 10 %lx\n", uiTemp);
|
|
|
|
uiTemp = GetNearestPaletteIndex(hpal1, 0x00FFFFFF);
|
|
|
|
if (uiTemp != 15)
|
|
DbgPrint("GetNearestPaletteIndex failed 15 %lx\n", uiTemp);
|
|
|
|
uiTemp = GetNearestPaletteIndex(hpal1, PALETTEINDEX(5));
|
|
|
|
if (uiTemp != 5)
|
|
DbgPrint("GetNearestPaletteIndex failed 15 %lx\n", uiTemp);
|
|
|
|
uiTemp = GetNearestPaletteIndex(hpal1, PALETTEINDEX(10));
|
|
|
|
if (uiTemp != 10)
|
|
DbgPrint("GetNearestPaletteIndex failed 15 %lx\n", uiTemp);
|
|
|
|
if (!DeleteObject(hpal1))
|
|
DbgPrint("vTestPal1 failed to delete palette\n");
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vTestPal2
|
|
*
|
|
* Test palette stuff.
|
|
*
|
|
* History:
|
|
* 01-Sep-1991 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID vTestPal2(HDC hdc)
|
|
{
|
|
HPALETTE hpalDefault;
|
|
HBRUSH hbrDefault, hbr;
|
|
DWORD ulIndex, ulPal;
|
|
PALETTEENTRY palentry;
|
|
|
|
hpalDefault = GetStockObject(DEFAULT_PALETTE);
|
|
|
|
SelectPalette(hdc, hpalDefault, 0);
|
|
SelectPalette(hdc, hpalDefault, 0);
|
|
SelectPalette(hdc, hpalDefault, 0);
|
|
SelectPalette(hdc, hpalDefault, 0);
|
|
|
|
for (ulIndex = 0; ulIndex < 20; ulIndex++)
|
|
{
|
|
ulPal = PALETTEINDEX(ulIndex);
|
|
|
|
if (!(ulPal & 0x01000000))
|
|
DbgPrint("PALETTEINDEX failed to do it\n");
|
|
|
|
hbr = CreateSolidBrush(PALETTEINDEX(ulIndex));
|
|
hbrDefault = SelectObject(hdc, hbr);
|
|
PatBlt(hdc, ulIndex * 20, 0, 20, 20, PATCOPY);
|
|
SelectObject(hdc, hbrDefault);
|
|
DeleteObject(hbr);
|
|
|
|
GetPaletteEntries(hpalDefault, ulIndex, 1, (LPPALETTEENTRY) &ulPal);
|
|
|
|
hbr = CreateSolidBrush(ulPal);
|
|
hbrDefault = SelectObject(hdc, hbr);
|
|
PatBlt(hdc, ulIndex * 20, 20, 20, 20, PATCOPY);
|
|
SelectObject(hdc, hbrDefault);
|
|
DeleteObject(hbr);
|
|
|
|
GetPaletteEntries(hpalDefault, ulIndex, 1, (LPPALETTEENTRY) &palentry);
|
|
|
|
hbr = CreateSolidBrush(PALETTERGB(palentry.peRed, palentry.peGreen, palentry.peBlue));
|
|
hbrDefault = SelectObject(hdc, hbr);
|
|
PatBlt(hdc, ulIndex * 20, 40, 20, 20, PATCOPY);
|
|
SelectObject(hdc, hbrDefault);
|
|
DeleteObject(hbr);
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vTestPal3 and vTestPal4
|
|
*
|
|
* Test some SetDIBitsToDevice stuff.
|
|
*
|
|
* History:
|
|
* 06-Dec-1991 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
typedef struct _BITMAPINFO256
|
|
{
|
|
BITMAPINFOHEADER bmiHeader;
|
|
RGBQUAD bmiColors[256];
|
|
} BITMAPINFO256;
|
|
|
|
BYTE ajBuffer[64*64];
|
|
BITMAPINFO256 bmi256;
|
|
|
|
VOID vTestPal3(HDC hdc)
|
|
{
|
|
HBRUSH hbrR, hbrG, hbrB;
|
|
HDC hdc8;
|
|
HBITMAP hbm8;
|
|
|
|
if (GetDeviceCaps(hdc,BITSPIXEL) > 8)
|
|
return;
|
|
|
|
hbm8 = CreateCompatibleBitmap(hdc, 64, 64);
|
|
hdc8 = CreateCompatibleDC(hdc);
|
|
SelectObject(hdc8, hbm8);
|
|
|
|
hbrR = CreateSolidBrush(RGB(255,0,0));
|
|
hbrG = CreateSolidBrush(RGB(0,255,0));
|
|
hbrB = CreateSolidBrush(RGB(0,0,255));
|
|
|
|
SelectObject(hdc8, hbrR);
|
|
PatBlt(hdc8, 0, 0, 64, 64, PATCOPY);
|
|
SelectObject(hdc8, hbrG);
|
|
PatBlt(hdc8, 16, 16, 32, 32, PATCOPY);
|
|
SelectObject(hdc8, hbrB);
|
|
PatBlt(hdc8, 24, 24, 16, 16, PATCOPY);
|
|
|
|
// See what the bitmap looks like.
|
|
|
|
BitBlt(hdc, 0, 100, 64, 64, hdc8, 0, 0, SRCCOPY);
|
|
|
|
// Get the header
|
|
|
|
bmi256.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
bmi256.bmiHeader.biBitCount = 0;
|
|
|
|
GetDIBits(hdc8, hbm8, 0, 64, (PBYTE) NULL, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
// Get the color table
|
|
|
|
GetDIBits(hdc8, hbm8, 0, 64, (PBYTE) NULL, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
// Get the bits
|
|
|
|
if (64 != GetDIBits(hdc8, hbm8, 0, 64, (PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS))
|
|
DbgPrint("The GetDIBits failed vTestPal3\n");
|
|
|
|
// Look at the bits.
|
|
|
|
SetDIBitsToDevice(hdc, 64, 100, 64, 64, 0, 0, 0, 64,
|
|
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
// Do them left half right half
|
|
|
|
SetDIBitsToDevice(hdc, 128, 100, 32, 64, 0, 0, 0, 64,
|
|
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
SetDIBitsToDevice(hdc, 160, 100, 32, 64, 32, 0, 0, 64,
|
|
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
DeleteDC(hdc8);
|
|
DeleteObject(hbm8);
|
|
DeleteObject(hbrR);
|
|
DeleteObject(hbrG);
|
|
DeleteObject(hbrB);
|
|
}
|
|
|
|
VOID vTestPal4(HDC hdc)
|
|
{
|
|
HBRUSH hbrR, hbrG, hbrB;
|
|
HDC hdc8;
|
|
HBITMAP hbm4;
|
|
int i;
|
|
|
|
hbm4 = CreateBitmap(62, 62, 1, 4, NULL);
|
|
hdc8 = CreateCompatibleDC(hdc);
|
|
SelectObject(hdc8, hbm4);
|
|
|
|
hbrR = CreateSolidBrush(RGB(255,0,0));
|
|
hbrG = CreateSolidBrush(RGB(0,255,0));
|
|
hbrB = CreateSolidBrush(RGB(0,0,255));
|
|
|
|
SelectObject(hdc8, hbrR);
|
|
PatBlt(hdc8, 0, 0, 64, 64, PATCOPY);
|
|
SelectObject(hdc8, hbrG);
|
|
PatBlt(hdc8, 16, 16, 32, 32, PATCOPY);
|
|
SelectObject(hdc8, hbrB);
|
|
PatBlt(hdc8, 24, 24, 16, 16, PATCOPY);
|
|
|
|
// See what the bitmap looks like.
|
|
|
|
BitBlt(hdc, 0, 200, 64, 64, hdc8, 0, 0, SRCCOPY);
|
|
|
|
// Get the header
|
|
|
|
bmi256.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
bmi256.bmiHeader.biBitCount = 0;
|
|
|
|
GetDIBits(hdc8, hbm4, 0, 64, (PBYTE) NULL, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
bmi256.bmiHeader.biBitCount = 8;
|
|
|
|
// Get the color table
|
|
|
|
GetDIBits(hdc8, hbm4, 0, 64, (PBYTE) NULL, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
if (bmi256.bmiHeader.biBitCount != 8)
|
|
DbgPrint("Error bitcount wrong in vTestPal4\n");
|
|
|
|
// Get the bits
|
|
|
|
#if 0
|
|
|
|
if (62 != (i = GetDIBits(hdc8, hbm4, 0, 62, (PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS)))
|
|
DbgPrint("The GetDIBits failed vTestPal4 %d\n",i);
|
|
|
|
if (bmi256.bmiHeader.biBitCount != 8)
|
|
DbgPrint("Error bitcount wrong in vTestPal4\n");
|
|
#endif
|
|
|
|
// Look at the bits.
|
|
|
|
SetDIBitsToDevice(hdc, 64, 200, 64, 64, 0, 0, 0, 62,
|
|
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
// Do them left half right half
|
|
|
|
SetDIBitsToDevice(hdc, 128, 200, 32, 64, 0, 0, 0, 62,
|
|
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
SetDIBitsToDevice(hdc, 160, 200, 32, 64, 32, 0, 0, 62,
|
|
(PBYTE) ajBuffer, (LPBITMAPINFO) &bmi256, DIB_RGB_COLORS);
|
|
|
|
DeleteDC(hdc8);
|
|
DeleteObject(hbm4);
|
|
DeleteObject(hbrR);
|
|
DeleteObject(hbrG);
|
|
DeleteObject(hbrB);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vTestAnimatePalette
|
|
*
|
|
* This tests animating the palette.
|
|
*
|
|
* History:
|
|
* 26-Jun-1992 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID vTestAnimatePalette(HDC hdc, HPALETTE hpal)
|
|
{
|
|
PALETTEENTRY peTemp;
|
|
PALETTEENTRY palPalEntry[256];
|
|
DWORD ulIndex, ulTemp;
|
|
HPALETTE hpalTemp;
|
|
|
|
hpalTemp = SelectPalette(hdc,hpal,0);
|
|
RealizePalette(hdc);
|
|
|
|
if (0 == GetPaletteEntries(hpal, 0, 256, palPalEntry))
|
|
DbgPrint("GetPaletteEntries failed, return 0\n");
|
|
|
|
if (palPalEntry[1].peFlags != PC_RESERVED)
|
|
DbgPrint("GetPaletteEntries failed 1 flags\n");
|
|
|
|
if (palPalEntry[1].peRed != 1)
|
|
DbgPrint("GetPaletteEntries failed 1\n");
|
|
|
|
if (palPalEntry[2].peFlags != PC_RESERVED)
|
|
DbgPrint("GetPaletteEntries failed 2 flags\n");
|
|
|
|
if (palPalEntry[2].peRed != 2)
|
|
DbgPrint("GetPaletteEntries failed 2\n");
|
|
|
|
for (ulIndex = 0; ulIndex < 256; ulIndex++)
|
|
{
|
|
peTemp = palPalEntry[0];
|
|
|
|
for (ulTemp = 0; ulTemp < 255; ulTemp++)
|
|
{
|
|
palPalEntry[ulTemp] =
|
|
palPalEntry[ulTemp + 1];
|
|
}
|
|
|
|
palPalEntry[255] = peTemp;
|
|
|
|
AnimatePalette(hpal, 0, 256, palPalEntry);
|
|
}
|
|
|
|
SelectPalette(hdc,hpalTemp,0);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vPaintStripes
|
|
*
|
|
* Paints stripes of every index onto surface.
|
|
*
|
|
* History:
|
|
* 26-Jun-1992 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID vPaintStripes(HDC hdc, RECT *prcl)
|
|
{
|
|
LOGPALETTE256 logPal256;
|
|
DWORD ulTemp;
|
|
HBRUSH hBrush, hOldBrush;
|
|
HPALETTE hpalExplicit,hpalTemp;
|
|
|
|
logPal256.palVersion = 0x300;
|
|
logPal256.palNumEntries = 256;
|
|
|
|
// Set up explicit palette.
|
|
|
|
for (ulTemp = 0; ulTemp < 256; ulTemp++)
|
|
{
|
|
logPal256.palPalEntry[ulTemp].peRed = (BYTE)ulTemp;
|
|
logPal256.palPalEntry[ulTemp].peGreen = 0;
|
|
logPal256.palPalEntry[ulTemp].peBlue = 0;
|
|
logPal256.palPalEntry[ulTemp].peFlags = PC_EXPLICIT;
|
|
}
|
|
|
|
hpalExplicit = CreatePalette((LOGPALETTE *) &logPal256);
|
|
hpalTemp = SelectPalette(hdc,hpalExplicit,0);
|
|
RealizePalette(hdc);
|
|
|
|
// Paint Surface with all colors.
|
|
|
|
for (ulTemp = 0; ulTemp < 256; ulTemp++)
|
|
{
|
|
hBrush = CreateSolidBrush(PALETTEINDEX(ulTemp));
|
|
hOldBrush = SelectObject(hdc,hBrush);
|
|
|
|
PatBlt(hdc,
|
|
(((prcl->right - prcl->left) * ulTemp) / 256),
|
|
0,
|
|
(((prcl->right - prcl->left) / 256) + 3) ,
|
|
(prcl->bottom - prcl->top),
|
|
PATCOPY);
|
|
|
|
SelectObject(hdc, hOldBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
SelectPalette(hdc,hpalTemp,0);
|
|
DeleteObject(hpalExplicit);
|
|
}
|
|
|
|
VOID vTestPal5(HDC hdc, RECT *prcl)
|
|
{
|
|
LOGPALETTE256 logPal256;
|
|
HPALETTE hpalR;
|
|
DWORD ulTemp;
|
|
|
|
vPaintStripes(hdc, prcl);
|
|
|
|
logPal256.palVersion = 0x300;
|
|
logPal256.palNumEntries = 256;
|
|
|
|
// Set up Red palette.
|
|
|
|
for (ulTemp = 0; ulTemp < 256; ulTemp++)
|
|
{
|
|
logPal256.palPalEntry[ulTemp].peRed = (BYTE)ulTemp;
|
|
logPal256.palPalEntry[ulTemp].peGreen = 0;
|
|
logPal256.palPalEntry[ulTemp].peBlue = 0;
|
|
logPal256.palPalEntry[ulTemp].peFlags = PC_RESERVED;
|
|
}
|
|
|
|
hpalR = CreatePalette((LOGPALETTE *) &logPal256);
|
|
vTestAnimatePalette(hdc, hpalR);
|
|
DeleteObject(hpalR);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vTestXlates
|
|
*
|
|
* Test creation deletion and use of palette xlates.
|
|
*
|
|
* History:
|
|
* 26-Jun-1992 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID vTestXlates(HDC hdc, RECT *prcl)
|
|
{
|
|
HPALETTE ahpal[4];
|
|
HPALETTE hPalOld;
|
|
DWORD ulTemp;
|
|
|
|
LOGPALETTE256 alog256[4];
|
|
|
|
alog256[0].palVersion = 0x300;
|
|
alog256[0].palNumEntries = 256;
|
|
alog256[1].palVersion = 0x300;
|
|
alog256[1].palNumEntries = 256;
|
|
alog256[2].palVersion = 0x300;
|
|
alog256[2].palNumEntries = 256;
|
|
alog256[3].palVersion = 0x300;
|
|
alog256[3].palNumEntries = 256;
|
|
|
|
for (ulTemp = 0; ulTemp < 256; ulTemp++)
|
|
{
|
|
alog256[0].palPalEntry[ulTemp].peRed = (BYTE)ulTemp;
|
|
alog256[0].palPalEntry[ulTemp].peBlue = 0;
|
|
alog256[0].palPalEntry[ulTemp].peGreen = 0;
|
|
alog256[0].palPalEntry[ulTemp].peFlags = 0;
|
|
|
|
alog256[1].palPalEntry[ulTemp].peRed = 0;
|
|
alog256[1].palPalEntry[ulTemp].peBlue = (BYTE)ulTemp;
|
|
alog256[1].palPalEntry[ulTemp].peGreen = 0;
|
|
alog256[1].palPalEntry[ulTemp].peFlags = 0;
|
|
|
|
alog256[2].palPalEntry[ulTemp].peRed = 0;
|
|
alog256[2].palPalEntry[ulTemp].peBlue = 0;
|
|
alog256[2].palPalEntry[ulTemp].peGreen = (BYTE)ulTemp;
|
|
alog256[2].palPalEntry[ulTemp].peFlags = PC_RESERVED;
|
|
|
|
alog256[3].palPalEntry[ulTemp].peRed = (BYTE)ulTemp;
|
|
alog256[3].palPalEntry[ulTemp].peBlue = (BYTE)ulTemp;
|
|
alog256[3].palPalEntry[ulTemp].peGreen = (BYTE)ulTemp;
|
|
alog256[3].palPalEntry[ulTemp].peFlags = PC_RESERVED;
|
|
}
|
|
|
|
ahpal[0] = CreatePalette((LOGPALETTE *) &alog256[0]);
|
|
ahpal[1] = CreatePalette((LOGPALETTE *) &alog256[1]);
|
|
ahpal[2] = CreatePalette((LOGPALETTE *) &alog256[2]);
|
|
ahpal[3] = CreatePalette((LOGPALETTE *) &alog256[3]);
|
|
|
|
hPalOld = SelectPalette(hdc,ahpal[0],0);
|
|
|
|
for (ulTemp = 0; ulTemp < 20; ulTemp++)
|
|
{
|
|
SelectPalette(hdc, ahpal[ulTemp % 4], 0);
|
|
RealizePalette(hdc);
|
|
UpdateColors(hdc);
|
|
SetPaletteEntries(ahpal[ulTemp % 4], 0, 256, alog256[ulTemp % 4].palPalEntry);
|
|
RealizePalette(hdc);
|
|
UpdateColors(hdc);
|
|
}
|
|
|
|
SelectPalette(hdc,hPalOld,0);
|
|
|
|
DeleteObject(ahpal[0]);
|
|
DeleteObject(ahpal[1]);
|
|
DeleteObject(ahpal[2]);
|
|
DeleteObject(ahpal[3]);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vDrawStuff6
|
|
*
|
|
* Draw picture on a surface.
|
|
*
|
|
* History:
|
|
* 02-Jan-1993 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
void vDrawStuff6(HDC hdc, RECT *prclBound)
|
|
{
|
|
DWORD dwTemp;
|
|
HBRUSH hBrush, hOldBrush;
|
|
|
|
// Paint the PALETTEINDEX stripes.
|
|
|
|
vPaintStripes(hdc, prclBound);
|
|
|
|
// Paint PALETTEINDEX stripes.
|
|
|
|
for (dwTemp = 0; dwTemp < 256; dwTemp++)
|
|
{
|
|
hBrush = CreateSolidBrush(PALETTEINDEX(dwTemp));
|
|
hOldBrush = SelectObject(hdc,hBrush);
|
|
|
|
PatBlt(hdc,
|
|
(((prclBound->right - prclBound->left) * dwTemp) / 256),
|
|
75,
|
|
(((prclBound->right - prclBound->left) / 256) + 3),
|
|
75,
|
|
PATCOPY);
|
|
|
|
SelectObject(hdc, hOldBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
// Paint the RGB stripes.
|
|
|
|
for (dwTemp = 0; dwTemp < 256; dwTemp++)
|
|
{
|
|
hBrush = CreateSolidBrush(RGB(dwTemp,0,0));
|
|
hOldBrush = SelectObject(hdc,hBrush);
|
|
|
|
PatBlt(hdc,
|
|
(((prclBound->right - prclBound->left) * dwTemp) / 256),
|
|
150,
|
|
(((prclBound->right - prclBound->left) / 256) + 3),
|
|
75,
|
|
PATCOPY);
|
|
|
|
SelectObject(hdc, hOldBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
|
|
// Paint the PALETTERGB stripes.
|
|
|
|
for (dwTemp = 0; dwTemp < 256; dwTemp++)
|
|
{
|
|
hBrush = CreateSolidBrush(PALETTERGB(dwTemp,0,0));
|
|
hOldBrush = SelectObject(hdc,hBrush);
|
|
|
|
PatBlt(hdc,
|
|
(((prclBound->right - prclBound->left) * dwTemp) / 256),
|
|
225,
|
|
(((prclBound->right - prclBound->left) / 256) + 3),
|
|
75,
|
|
PATCOPY);
|
|
|
|
SelectObject(hdc, hOldBrush);
|
|
DeleteObject(hBrush);
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vTestPal6
|
|
*
|
|
* This is a test that also runs under Win3.1
|
|
*
|
|
* History:
|
|
* 02-Jan-1993 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
void vTestPal6(HWND hwnd, HDC hdc)
|
|
{
|
|
RECT rclBound;
|
|
LOGPALETTE256 logPal256;
|
|
HPALETTE hpalR, hpalTemp, hpalTemp1;
|
|
HDC hdcMem;
|
|
HBITMAP hbmMem,hbmTemp;
|
|
DWORD dwTemp;
|
|
|
|
// Get the bounding rectangle.
|
|
|
|
GetClientRect(hwnd, &rclBound);
|
|
|
|
// Create Bitmap half size of client area.
|
|
|
|
hdcMem = CreateCompatibleDC(hdc);
|
|
hbmMem = CreateCompatibleBitmap(hdc, rclBound.right - rclBound.left, 300);
|
|
hbmTemp = SelectObject(hdcMem, hbmMem);
|
|
|
|
// Set up Red palette.
|
|
|
|
logPal256.palVersion = 0x300;
|
|
logPal256.palNumEntries = 256;
|
|
|
|
for (dwTemp = 0; dwTemp < 256; dwTemp++)
|
|
{
|
|
logPal256.palPalEntry[dwTemp].peRed = (BYTE) dwTemp;
|
|
logPal256.palPalEntry[dwTemp].peGreen = 0;
|
|
logPal256.palPalEntry[dwTemp].peBlue = 0;
|
|
logPal256.palPalEntry[dwTemp].peFlags = PC_RESERVED;
|
|
}
|
|
|
|
hpalR = CreatePalette((LOGPALETTE *) &logPal256);
|
|
|
|
hpalTemp = SelectPalette(hdc, hpalR, 0);
|
|
RealizePalette(hdc);
|
|
vDrawStuff6(hdc, &rclBound);
|
|
|
|
hpalTemp1 = SelectPalette(hdcMem, hpalR, 0);
|
|
RealizePalette(hdcMem);
|
|
vDrawStuff6(hdcMem, &rclBound);
|
|
|
|
BitBlt(hdc, 0, 300, rclBound.right - rclBound.left, 300, hdcMem, 0, 0, SRCCOPY);
|
|
|
|
// Animate the palette.
|
|
|
|
vTestAnimatePalette(hdc, hpalR);
|
|
|
|
// Clean up.
|
|
|
|
SelectObject(hdcMem, hbmTemp);
|
|
SelectPalette(hdc, hpalTemp,0);
|
|
SelectPalette(hdc, hpalTemp1,0);
|
|
|
|
DeleteDC(hdcMem);
|
|
DeleteObject(hpalR);
|
|
DeleteObject(hbmMem);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vTestPalettes
|
|
*
|
|
* Does various tests of palette code.
|
|
*
|
|
* History:
|
|
* 31-Aug-1991 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID vTestPalettes(HWND hwnd, HDC hdc, RECT* prcl)
|
|
{
|
|
DWORD ul1,ul2;
|
|
|
|
hwnd;
|
|
|
|
PatBlt(hdc, 0, 0, 10000, 10000, WHITENESS);
|
|
|
|
vTestPal5(hdc, prcl);
|
|
vTestPal1();
|
|
vTestPal2(hdc);
|
|
vTestPal3(hdc);
|
|
vTestPal4(hdc);
|
|
vTestXlates(hdc,prcl);
|
|
vTestPal6(hwnd, hdc);
|
|
|
|
ul1 = GetSystemPaletteEntries(hdc, 0,0, NULL);
|
|
ul2 = GetDeviceCaps(hdc, SIZEPALETTE);
|
|
|
|
if (ul1 != ul2)
|
|
DbgPrint("vTestPalettes failed on system size %lu %lu\n", ul1, ul2);
|
|
}
|