ï¿½ï¿½Ê½16-1  GRAYS1
GRAYS1.C
/*---------------------------------------------------------------------------
   	GRAYS1.C -- 	Gray Shades
               						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    		PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("Grays1") ;
     	HWND         			hwnd ;
     	MSG          			msg ;
     	WNDCLASS     			wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= 	hInstance ;
     	wndclass.hIcon         			= 	LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= 	LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= 	(HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= 	NULL ;
     	wndclass.lpszClassName 		= 	szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      			szAppName, MB_ICONERROR) ;
          			return 0 ;
     	}
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Shades of Gray #1"),
                               WS_OVERLAPPEDWINDOW,
                          	   CW_USEDEFAULT, CW_USEDEFAULT,
                          	   CW_USEDEFAULT, CW_USEDEFAULT,             
                          	   NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static int  		cxClient, cyClient ;
     	HBRUSH      		hBrush ;
     	HDC         		hdc ;
     	int         		i ;
     	PAINTSTRUCT 		ps ;
     	RECT        		rect ;
     
     	switch (message)
     	{
     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

               					// Draw the fountain of grays

          			for (i = 0 ; i < 65 ; i++)
          			{
               					rect.left   		= i * cxClient / 65 ;
               					rect.top    		= 0 ;
               					rect.right  		= (i + 1) * cxClient / 65 ;
               					rect.bottom 		= cyClient ;

               			hBrush = CreateSolidBrush (RGB(min (255, 4 * i),	
								min (255, 4 * i), 
								min (255, 4 * i))) ;
               					FillRect (hdc, &rect, hBrush) ;
               					DeleteObject (hBrush) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 ï¿½ï¿½Ê½16-2  GRAYS2
GRAYS2.C
/*---------------------------------------------------------------------------
   	GRAYS2.C -- 	Gray Shades Using Palette Manager
               						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("Grays2") ;
     	HWND         			hwnd ;
     	MSG          			msg ;
     	WNDCLASS     			wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;

     	if	(!	RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      			szAppName, MB_ICONERROR) ;
			return 0 ;
     	}
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Shades of Gray #2"),
                          		WS_OVERLAPPEDWINDOW,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,             
                          		NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
        			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HPALETTE 		hPalette ;
     	static int      		cxClient, cyClient ;
     	HBRUSH          		hBrush ;
     	HDC             		hdc ;
     	int             		i ;
     	LOGPALETTE    			* 	plp ;
     	PAINTSTRUCT     		ps ;
     	RECT            		rect ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
               				// Set up a LOGPALETTE structure and create a palette

          			plp = malloc (sizeof (LOGPALETTE) + 64 * sizeof (PALETTEENTRY)) ;

          			plp->palVersion  	= 0x0300 ;
          			plp->palNumEntries	= 65 ;

          			for (i = 0 ; i < 65 ; i++)
          {
               		plp->palPalEntry[i].peRed   	= (BYTE) min (255, 4 * i) ;
               		plp->palPalEntry[i].peGreen 	= (BYTE) min (255, 4 * i) ;
               		plp->palPalEntry[i].peBlue 	= (BYTE) min (255, 4 * i) ;
               		plp->palPalEntry[i].peFlags 	= 0 ;
          			}
          			hPalette = CreatePalette (plp) ;
          			free (plp) ;
          			return 0 ;

     	case	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

               				// Select and realize the palette in the device context

          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;

               				// Draw the fountain of grays

          			for (i = 0 ; i < 65 ; i++)
          			{
               				rect.left   		= i * cxClient / 64 ;
               				rect.top    		= 0 ;
               				rect.right  		= (i + 1) * cxClient / 64 ;
               				rect.bottom 		= cyClient ;

              			 hBrush = CreateSolidBrush (PALETTERGB(	min	(255, 4 * i), 
                                                           min	(255, 4 * i), 
                                                           min	(255, 4 * i))) ;
               				FillRect (hdc, &rect, hBrush) ;
               				DeleteObject (hBrush) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hPalette)
               					return FALSE ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;
  
          			ReleaseDC (hwnd, hdc) ;
          			break ;

     	case 	WM_DESTROY:
          			DeleteObject (hPalette) ;
          			PostQuitMessage (0) ;
          			return 0 ;
	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

typedef struct
{
     	WORD         	palVersion ;
     	WORD         	palNumEntries ;
     	PALETTEENTRY 	palPalEntry[1] ;
}
LOGPALETTE, * PLOGPALETTE ;

typedef struct
{
     	BYTE peRed ;
     	BYTE peGreen ;
     	BYTE peBlue ;
     	BYTE peFlags ;
}
PALETTEENTRY, * PPALETTEENTRY ;

 ï¿½ï¿½Ê½16-3  GRAYS3
GRAYS3.C
/*---------------------------------------------------------------------------
   	GRAYS3.C -- 	Gray Shades Using Palette Manager
               						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR szAppName[] = TEXT ("Grays3") ;
	HWND         					hwnd ;
     	MSG          				msg ;
     	WNDCLASS     				wndclass ;
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     {
         	 		MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      					szAppName, MB_ICONERROR) ;
      			return 0 ;
     	}
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Shades of Gray #3"),
                          		WS_OVERLAPPEDWINDOW,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,             
                          		NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
         			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HPALETTE 		hPalette ;
     	static int      		cxClient, cyClient ;
     	HBRUSH          		hBrush ;
    	HDC             		hdc ;
     	int             		i ;
     	LOGPALETTE    			* 	plp ;
     	PAINTSTRUCT     		ps ;
     	RECT            		rect ;
     	switch (message)
     {
     	case 	WM_CREATE:
               			// 	Set up a LOGPALETTE structure and create a palette

          			plp = malloc (sizeof (LOGPALETTE) + 64 * sizeof (PALETTEENTRY)) ;

          			plp->palVersion 		= 0x0300 ;
          			plp->palNumEntries	= 65 ;

          			for (i = 0 ; i < 65 ; i++)
          			{
               		plp->palPalEntry[i].peRed   	= (BYTE) min (255, 4 * i) ;
               		plp->palPalEntry[i].peGreen 	= (BYTE) min (255, 4 * i) ;
               		plp->palPalEntry[i].peBlue  	= (BYTE) min (255, 4 * i) ;
               		plp->palPalEntry[i].peFlags 	= 0 ;
          			}
 			hPalette = CreatePalette (plp) ;
         			free (plp) ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

   				// Select and realize the palette in the device context

    				SelectPalette (hdc, hPalette, FALSE) ;
 				RealizePalette (hdc) ;

               				// Draw the fountain of grays

			for (i = 0 ; i < 65 ; i++)
			{
               				rect.left   	= i * cxClient / 64 ;
               				rect.top    	= 0 ;
               				rect.right  	= (i + 1) * cxClient / 64 ;
               				rect.bottom 	= cyClient ;

               				hBrush = CreateSolidBrush (PALETTEINDEX (i)) ;

               				FillRect (hdc, &rect, hBrush) ;
               				DeleteObject (hBrush) ;
          			}

          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hPalette)
               					return FALSE ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, FALSE) ;
     
          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc 	= GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;

     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

PALETTEINDEX (0)

PALETTEINDEX (32)

PALETTEINDEX (64)

RC_PALETTE & GetDeviceCaps (hdc, RASTERCAPS)

GetDeviceCaps (hdc, SIZEPALETTE)

GetDeviceCaps (hdc, NUMRESERVED)

GetDeviceCaps (hdc, COLORRES)

GetSystemPaletteEntries (hdc, uStart, uNum, &pe) ;

PALETTEENTRY pe ;

GetSystemPaletteEntries (hdc, i, 1, &pe) ;

GetPaletteEntries (hPalette, uStart, uNum, &pe) ;

SetPaletteEntries (hPalette, uStart, uNum, &pe) ;

iIndex = GetNearestPaletteIndex (hPalette, cr) ;

 ï¿½ï¿½Ê½16-4  SYSPAL1
SYSPAL1.C
/*---------------------------------------------------------------------------
   SYSPAL1.C --	Displays system palette
         						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

TCHAR szAppName [] = TEXT ("SysPal1") ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HWND     			hwnd ;
     	MSG      			msg ;
     	WNDCLASS 			wndclass ;
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		    = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  			= NULL ;
     	wndclass.lpszClassName 			= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
			MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      				szAppName, MB_ICONERROR) ;
          			return 0 ;
     	}
     
     	hwnd = CreateWindow (	szAppName, TEXT ("System Palette #1"), 
                          	WS_OVERLAPPEDWINDOW, 
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;

     	if (!hwnd)
          			return 0 ;
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

BOOL CheckDisplay (HWND hwnd)
{
     	HDC	hdc ;
     	int 	iPalSize ;

     	hdc = GetDC (hwnd) ;
     	iPalSize = GetDeviceCaps (hdc, SIZEPALETTE) ;
     	ReleaseDC (hwnd, hdc) ;

     	if (iPalSize != 256)
  	{
		MessageBox (hwnd,TEXT ("This program requires that the video ")
                         TEXT ("display mode have a 256-color palette."),
                      	    	szAppName, MB_ICONERROR) ;
          		return FALSE ;
     	}
     	return TRUE ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static int   		cxClient, cyClient ;
     	static SIZE  		sizeChar ;
     	HDC          		hdc ;
     	HPALETTE     		hPalette ;
     	int             	i, x, y ;
     	PAINTSTRUCT  		ps ;
     	PALETTEENTRY 		pe [256] ;
     	TCHAR        					szBuffer [16] ;

     	switch (message)
     	{
     	case WM_CREATE:
          			if (!CheckDisplay (hwnd))
               					return -1 ;
          			hdc = GetDC (hwnd) ;
          			SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
          			GetTextExtentPoint32 (hdc, TEXT ("FF-FF-FF"), 10, &sizeChar) ;
          			ReleaseDC (hwnd, hdc) ;
          			return 0 ;
     
     	case 	WM_DISPLAYCHANGE:
          			if (!CheckDisplay (hwnd))
               					DestroyWindow (hwnd) ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          			SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

          			GetSystemPaletteEntries (hdc, 0, 256, pe) ;

          			for (i = 0, x = 0, y = 0 ; i < 256 ; i++)
          			{
               		wsprintf (	szBuffer, TEXT ("%02X-%02X-%02X"),
                    pe[i].peRed, pe[i].peGreen, pe[i].peBlue) ;

               		TextOut (hdc, x, y, szBuffer, lstrlen (szBuffer)) ;

               		if ((	x += sizeChar.cx) + sizeChar.cx > cxClient)
               					{
                    					x = 0 ;
          
                    					if ((	y += sizeChar.cy) > cyClient)
                         						break ;
               					}
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_PALETTECHANGED:
          			InvalidateRect (hwnd, NULL, FALSE) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 ï¿½ï¿½Ê½16-5  SYSPAL2
SYSPAL2.C
/*---------------------------------------------------------------------------
   SYSPAL2.C --	Displays system palette
          						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

TCHAR szAppName [] = TEXT ("SysPal2") ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    		PSTR szCmdLine, int iCmdShow)
{
     	HWND     				hwnd ;
     	MSG      				msg ;
     	WNDCLASS 			wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
	wndclass.hIcon         				= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, TEXT ("System Palette #2"), 
                          		WS_OVERLAPPEDWINDOW, 
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		NULL, NULL, hInstance, NULL) ;
     	if (!hwnd)
          			return 0 ;
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

BOOL CheckDisplay (HWND hwnd)
{
     	HDC hdc ;
     	int iPalSize ;

     	hdc = GetDC (hwnd) ;
     	iPalSize = GetDeviceCaps (hdc, SIZEPALETTE) ;
     	ReleaseDC (hwnd, hdc) ;

	if (iPalSize != 256)
     	{
 	MessageBox (hwnd, TEXT	("This program requires that the video ")
                      TEXT	("display mode have a 256-color palette."),
                      		szAppName, MB_ICONERROR) ;
          		return FALSE ;
     	}
     	return TRUE ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HPALETTE 		hPalette ;
     	static int      		cxClient, cyClient ;
     	HBRUSH          		hBrush ;
     	HDC             		hdc ;
     	int             		i, x, y ;
     	LOGPALETTE    			* 	plp ;
     	PAINTSTRUCT     		ps ;
     	RECT            		rect ;

     	switch (message)
     {
     	case 	WM_CREATE:
          			if (!CheckDisplay (hwnd))
               					return -1 ;

			plp = malloc (sizeof (LOGPALETTE) + 255 * sizeof (PALETTEENTRY)) ;

			plp->palVersion 			= 0x0300 ;
			plp->palNumEntries 		= 256 ;

 			for (i = 0 ; i < 256 ; i++)
			{
					plp->palPalEntry[i].peRed   		= i ;
					plp->palPalEntry[i].peGreen 		= 0 ;
               					plp->palPalEntry[i].peBlue  	= 0 ;
               					plp->palPalEntry[i].peFlags 	= PC_EXPLICIT ;
         	 		}
          
			hPalette = CreatePalette (plp) ;
			free (plp) ;          
			return 0 ;
     
	case 	WM_DISPLAYCHANGE:
          			if (!CheckDisplay (hwnd))
               					DestroyWindow (hwnd) ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;

          			for (y = 0 ; y < 16 ; y++)
          			for (x = 0 ; x < 16 ; x++)
          			{
               				hBrush = CreateSolidBrush (PALETTEINDEX (16 * y + x)) ;
               				SetRect (&rect, x 	* cxClient /16, y	* cyClient / 16,
                             (x + 1)`	* 	cxClient	/	16,(y+1)	* cyClient / 16);
               				FillRect (hdc, &rect, hBrush) ;
               				DeleteObject (hBrush) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_PALETTECHANGED:
          			if ((HWND) wParam != hwnd)
               					InvalidateRect (hwnd, NULL, FALSE) ;

          			return 0 ;

     	case 	WM_DESTROY:
          			DeleteObject (hPalette) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 ï¿½ï¿½Ê½16-6  SYSPAL3
SYSPAL3.C
/*---------------------------------------------------------------------------
   	SYSPAL3.C -- 	Displays system palette
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("SysPal3") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HWND     			hwnd ;
     	MSG      			msg ;
     	WNDCLASS 		wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      								szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}

	hwnd = CreateWindow (	szAppName, TEXT ("System Palette #3"), 
                          	WS_OVERLAPPEDWINDOW, 
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;

	if (!hwnd)
          			return 0 ;
	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

BOOL CheckDisplay (HWND hwnd)
{
     	HDC hdc ;
     	int iPalSize ;

     	hdc = GetDC (hwnd) ;
     	iPalSize = GetDeviceCaps (hdc, SIZEPALETTE) ;
     	ReleaseDC (hwnd, hdc) ;

     	if (iPalSize != 256)
     	{
       MessageBox (hwnd,TEXT("This program requires that the video ")
                        TEXT("display mode have a 256-color palette."),
                      		 szAppName, MB_ICONERROR) ;
          			return FALSE ;
     	}
	return TRUE ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HBITMAP hBitmap ;
     	static int     			cxClient, cyClient ;
     	BYTE           			bits [256] ;
     	HDC            			hdc, hdcMem ;
     	int            			i ;
     	PAINTSTRUCT    			ps ;

     	switch (message)
     	{
     	case 	WM_CREATE:
          			if (!	CheckDisplay (hwnd))
               						return -1 ;

          			for (	i = 0 ; i < 256 ; i++)
               				 		bits [i] = i ;
          
          			hBitmap = CreateBitmap (16, 16, 1, 8, &bits) ;
          			return 0 ;
                                                        
     	case 	WM_DISPLAYCHANGE:
          			if (!CheckDisplay (hwnd))
               					DestroyWindow (hwnd) ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			hdcMem = CreateCompatibleDC (hdc) ;
          			SelectObject (hdcMem, hBitmap) ;

          			StretchBlt (hdc,    0, 0, cxClient, cyClient,
          					    hdcMem, 0, 0, 16, 16, SRCCOPY) ;

          			DeleteDC (hdcMem) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
     	case 	WM_DESTROY:
          			DeleteObject (hBitmap) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 ï¿½ï¿½Ê½16-7  BOUNCE
PALANIM.C
/*--------------------------------------------------------------------------
   	PALANIM.C -- 	Palette Animation Shell Program
                						s(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
extern HPALETTE 	CreateRoutine  		(HWND) ;
extern void     		PaintRoutine   	(HDC, int, int) ;
extern void     		TimerRoutine   	(HDC, HPALETTE) ;
extern void     		DestroyRoutine 	(HWND, HPALETTE) ;

LRESULT 	CALLBA CK 	WndProc  (HWND, UINT, WPARAM, LPARAM) ;

extern TCHAR szAppName [] ;
extern TCHAR szTitle [] ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HWND     				hwnd ;
     	MSG      				msg ;
     	WNDCLASS 			wndclass ;
     	wndclass.style         		    = CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, szTitle, 
                          WS_OVERLAPPEDWINDOW, 
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

     	if (!hwnd)
          			return 0 ;
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     {
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

BOOL CheckDisplay (HWND hwnd)
{
     	HDC hdc ;
     	int iPalSize ;

     	hdc = GetDC (hwnd) ;
     	iPalSize = GetDeviceCaps (hdc, SIZEPALETTE) ;
     	ReleaseDC (hwnd, hdc) ;

	if (iPalSize != 256)
     	{
      MessageBox (hwnd,	TEXT ("This program requires that the video ")
                        TEXT ("display mode have a 256-color palette."),
                      		szAppName, MB_ICONERROR) ;
          		return FALSE ;
     	}
     	return TRUE ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HPALETTE 	hPalette ;
     	static int      			cxClient, cyClient ;
     	HDC             					hdc ;
     	PAINTSTRUCT     			ps ;

     	switch (message)
     	{
     	case 	WM_CREATE:
     			if (!CheckDisplay (hwnd))
        					return -1 ;

     			hPalette = CreateRoutine (hwnd) ;
      			return 0 ;
     
  	case 	WM_DISPLAYCHANGE:
      			if (!CheckDisplay (hwnd))
         					DestroyWindow (hwnd) ;

     			return 0 ;

  	case 	WM_SIZE:
     			cxClient = LOWORD (lParam) ;
     			cyClient = HIWORD (lParam) ;
     			return 0 ;

 	case 	WM_PAINT:
      			hdc = BeginPaint (hwnd, &ps) ;

     			SelectPalette (hdc, hPalette, FALSE) ;
     			RealizePalette (hdc) ;

     			PaintRoutine (hdc, cxClient, cyClient) ;

     			EndPaint (hwnd, &ps) ;
     			return 0 ;
 	case 	WM_TIMER:
     			hdc = GetDC (hwnd) ;

     			SelectPalette (hdc, hPalette, FALSE) ;

      			TimerRoutine (hdc, hPalette) ;

          			ReleaseDC (hwnd, hdc) ;
          			return 0 ;

   	case 	WM_QUERYNEWPALETTE:
			if (!hPalette)
					return FALSE ;

			hdc = GetDC (hwnd) ;
			SelectPalette (hdc, hPalette, FALSE) ;
			RealizePalette (hdc) ;
			InvalidateRect (hwnd, NULL, TRUE) ;

			ReleaseDC (hwnd, hdc) ;
			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;

     	case 	WM_DESTROY:
          			DestroyRoutine (hwnd, hPalette) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 BOUNCE.C
/*--------------------------------------------------------------------------
   	BOUNCE.C -- 	Palette Animation Demo
               						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#define ID_TIMER 1
TCHAR szAppName 	[] = TEXT ("Bounce") ;
TCHAR szTitle   	[] = TEXT ("Bounce: Palette Animation Demo") ;

static LOGPALETTE * plp ;
HPALETTE CreateRoutine (HWND hwnd)
{
     	HPALETTE 		hPalette ;
     	int 			i ;

     	plp = malloc (sizeof (LOGPALETTE) + 33 * sizeof (PALETTEENTRY)) ;
     	plp->palVersion 		= 0x0300 ;
     	plp->palNumEntries	= 34 ;

     	for (i = 0 ; i < 34 ; i++)
     	{
          			plp->palPalEntry[i].peRed   	= 255 ;
          			plp->palPalEntry[i].peGreen 	= (i == 0 ? 0 : 255) ;
          			plp->palPalEntry[i].peBlue  	= (i == 0 ? 0 : 255) ;
          			plp->palPalEntry[i].peFlags 	= (i == 33 ? 0 : PC_RESERVED) ;
     }
	hPalette = CreatePalette (plp) ;
	SetTimer (hwnd, ID_TIMER, 50, NULL) ;
	return hPalette ;
}

void PaintRoutine (HDC hdc, int cxClient, int cyClient)
{
     	HBRUSH 	hBrush ;
     	int  		i, x1, x2, y1, y2 ;
     	RECT 		rect ;
          				// Draw window background using palette index 33

     	SetRect (&rect, 0, 0, cxClient, cyClient) ;
     	hBrush = CreateSolidBrush (PALETTEINDEX (33)) ;
	FillRect (hdc, &rect, hBrush) ;
	DeleteObject (hBrush) ;

          			// Draw the 33 balls
     	SelectObject (hdc, GetStockObject (NULL_PEN)) ;
     	for (i = 0 ; i < 33 ; i++)
     	{
          			x1 =  i * cxClient / 33 ;
          			x2 = (i + 1)* cxClient / 33 ;

          			if (i < 9)
          			{
               				y1  = i * cyClient / 9 ;
               				y2 = (i + 1) * cyClient / 9 ;
      				}
          		else if (i < 17)
          				{
               				y1 = (16 - i) * cyClient / 9 ;
               				y2 = (17 - i) * cyClient / 9 ;
          				}
          		else if (i < 25)
          		{
               				y1 = (i - 16) * cyClient / 9 ;
               				y2 = (i - 15) * cyClient / 9 ;
          		}
          		else 
          		{
               				y1 = (32 - i) * cyClient / 9 ;
               				y2 = (33 - i) * cyClient / 9 ;
          		}

          		hBrush = CreateSolidBrush (PALETTEINDEX (i)) ;
          		SelectObject (hdc, hBrush) ;
          		Ellipse (hdc, x1, y1, x2, y2) ;
          		DeleteObject (SelectObject (hdc, GetStockObject (WHITE_BRUSH))) ;
     	}
     	return ;
}

void TimerRoutine (HDC hdc, HPALETTE hPalette)
{
  	static BOOL bLeftToRight = TRUE ;
     	static int  iBall ;

          		// Set old ball to white
     	plp->palPalEntry[iBall].peGreen = 255 ;
     	plp->palPalEntry[iBall].peBlue  = 255 ;

     	iBall += (bLeftToRight ? 1 : -1) ;
     	if (	iBall == (bLeftToRight ? 33 : -1))
     	{
          			iBall = (bLeftToRight ? 31 : 1) ;
          			bLeftToRight ^= TRUE ;
     	}

          		// Set new ball to red

     	plp->palPalEntry[iBall].peGreen = 0 ;
     	plp->palPalEntry[iBall].peBlue  = 0 ;

          		// Animate the palette

     	AnimatePalette (hPalette, 0, 33, plp->palPalEntry) ;
     	return ;
}

void DestroyRoutine (HWND hwnd, HPALETTE hPalette)
{
     	KillTimer (hwnd, ID_TIMER) ;
     	DeleteObject (hPalette) ;
     	free (plp) ;
     	return ;
}

AnimatePalette (hPalette, uStart, uNum, &pe) ;

AnimatePalette (hPalette, 0, 33, plp->palPalEntry) ;

iBallMin = min (iBall, iBallOld) ;
AnimatePalette (hPal, iBallMin, 2, plp->palPalEntry + iBallMin) ;

PALETTEENTRY pe ;

pe.peRed   		= 255 ;
     	pe.peGreen 		= 255 ;
     	pe.peBlue  		= 255 ;
     	pe.peFlags 		= PC_RESERVED ;
     	AnimatePalette (hPalette, iBall, 1, &pe) ;

pe.peRed   		= 255 ;
     	pe.peGreen 		= 0 ;
     	pe.peBlue  		= 0 ;
     	pe.peFlags 		= PC_RESERVED ;
     	AnimatePalette (hPalette, iBall, 1, &pe) ;

 ï¿½ï¿½Ê½16-8  FADER
FADER.C
/*--------------------------------------------------------------------------
   	FADER.C -- 	Palette Animation Demo
              					(c) Charles Petzold, 1998
--------------------------------------------------------------------------*/

#include <windows.h>
#define ID_TIMER 1
TCHAR szAppName	[] 	= TEXT ("Fader") ;
TCHAR szTitle 	[]	= TEXT ("Fader: Palette Animation Demo") ;

static LOGPALETTE lp ;
HPALETTE CreateRoutine (HWND hwnd)
{
     	HPALETTE hPalette ;
     	lp.palVersion             		= 0x0300 ;
     	lp.palNumEntries          		= 1 ;
     	lp.palPalEntry[0].peRed   		= 255 ;
     	lp.palPalEntry[0].peGreen 		= 255 ;
     	lp.palPalEntry[0].peBlue  		= 255 ;
     	lp.palPalEntry[0].peFlags 		= PC_RESERVED ;
   
     	hPalette = CreatePalette (&lp) ;
     	SetTimer (hwnd, ID_TIMER, 50, NULL) ;
     	return hPalette ;
}

void 	PaintRoutine (HDC hdc, int cxClient, int cyClient)
{
    	static TCHAR 		szText [] = TEXT (" Fade In and Out ") ;
    	int          					x, y ;
     	SIZE         					sizeText ;

     	SetTextColor (hdc, PALETTEINDEX (0)) ;
     	GetTextExtentPoint32 (hdc, szText, lstrlen (szText), &sizeText) ;

     	for (x = 0 ; x < cxClient ; x += sizeText.cx)
     	for (y = 0 ; y < cyClient ; y += sizeText.cy)
     	{
          		TextOut (hdc, x, y, szText, lstrlen (szText)) ;
     	}

     	return ;
}

void TimerRoutine (HDC hdc, HPALETTE hPalette)
{
     	static BOOL bFadeIn = TRUE ;
     	if (bFadeIn)
     	{
          			lp.palPalEntry[0].peRed   -= 4 ;
          			lp.palPalEntry[0].peGreen -= 4 ;

          			if (	lp.palPalEntry[0].peRed == 3)
               					bFadeIn = FALSE ;
     	}
     	else
     	{
          			lp.palPalEntry[0].peRed   += 4 ;
          			lp.palPalEntry[0].peGreen += 4 ;

          			if 	 (lp.palPalEntry[0].peRed == 255)
               					bFadeIn = TRUE ;
     	}

     	AnimatePalette (hPalette, 0, 1, lp.palPalEntry) ;
     	return ;
}

void DestroyRoutine (HWND hwnd, HPALETTE hPalette)
{
     	KillTimer (hwnd, ID_TIMER) ;
     	DeleteObject (hPalette) ;
     	return ;
}

 ï¿½ï¿½Ê½16-9  ALLCOLOR
ALLCOLOR.C
/*---------------------------------------------------------------------------
   	ALLCOLOR.C -- 		Palette Animation Demo
                 							(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#define ID_TIMER    1

TCHAR szAppName 	[] = TEXT ("AllColor") ;
TCHAR szTitle   	[] = TEXT ("AllColor: Palette Animation Demo") ;

static 	int          				iIncr ;
static 	PALETTEENTRY 	pe ;

HPALETTE CreateRoutine (HWND hwnd)
{
     	HDC        		hdc ;
	HPALETTE   			hPalette ;
     	LOGPALETTE 		lp ;

          			// Determine the color resolution and set iIncr
     	hdc = GetDC (hwnd) ;
     	iIncr = 1 << (8 - GetDeviceCaps (hdc, COLORRES) / 3) ;
     	ReleaseDC (hwnd, hdc) ;

          			// Create the logical palette
     	lp.palVersion             	    = 0x0300 ;
     	lp.palNumEntries         	 	= 1 ;
     	lp.palPalEntry[0].peRed   		= 0 ;
     	lp.palPalEntry[0].peGreen 		= 0 ;
     	lp.palPalEntry[0].peBlue  		= 0 ;
     	lp.palPalEntry[0].peFlags 		= PC_RESERVED ;
   
     	hPalette = CreatePalette (&lp) ;
          			// Save global for less typing
     	pe = lp.palPalEntry[0] ;
     	SetTimer (hwnd, ID_TIMER, 10, NULL) ;
     	return hPalette ;
}

void DisplayRGB (HDC hdc, PALETTEENTRY * ppe)
{
     	TCHAR szBuffer [16] ;
     	wsprintf (szBuffer, TEXT (" %02X-%02X-%02X "),
               					ppe->peRed, ppe->peGreen, ppe->peBlue) ;
     	TextOut (hdc, 0, 0, szBuffer, lstrlen (szBuffer)) ;
}

void PaintRoutine (HDC hdc, int cxClient, int cyClient)
{
     	HBRUSH   		hBrush ;
     	RECT     			rect ;

          			// Draw Palette Index 0 on entire window

	hBrush = CreateSolidBrush (PALETTEINDEX (0)) ;
     	SetRect (&rect, 0, 0, cxClient, cyClient) ;
     	FillRect (hdc, &rect, hBrush) ;
     	DeleteObject (SelectObject (hdc, GetStockObject (WHITE_BRUSH))) ;
          			// Display the RGB value
     	DisplayRGB (hdc, &pe) ;
     	return ;
}

void TimerRoutine (HDC hdc, HPALETTE hPalette)
{
     	static BOOL  bRedUp = TRUE, bGreenUp = TRUE, bBlueUp = TRUE ;
          					// Define new color value
     	pe.peBlue += (bBlueUp ? iIncr : -iIncr) ;
     	if (	pe.peBlue == (BYTE) (bBlueUp ? 0 : 256 - iIncr))
     	{
      			pe.peBlue = (bBlueUp ? 256 - iIncr : 0) ;
          			bBlueUp ^= TRUE ;
          			pe.peGreen += (bGreenUp ? iIncr : -iIncr) ;

          		if (	pe.peGreen == (BYTE) (bGreenUp ? 0 : 256 - iIncr))
          	{
					pe.peGreen = (bGreenUp ? 256 - iIncr : 0) ;
               					bGreenUp ^= TRUE ;
					pe.peRed += (bRedUp ? iIncr : -iIncr) ;

               					if (	pe.peRed == (BYTE) (bRedUp ? 0 : 256 - iIncr))
               					{
                    					pe.peRed = (bRedUp ? 256 - iIncr : 0) ;
                    					bRedUp ^= TRUE ;
               					}
          			}
	 }

          					// Animate the palette
     	AnimatePalette (hPalette, 0, 1, &pe) ;
     	DisplayRGB (hdc, &pe) ;
     	return ;
}

void DestroyRoutine (HWND hwnd, HPALETTE hPalette)
{
     	KillTimer (hwnd, ID_TIMER) ;
     	DeleteObject (hPalette) ;
     	return ;
}

 PIPES.C
/*-------------------------------------------------------------------------
   	PIPES.C -- 		Palette Animation Demo
              						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
#define ID_TIMER 1
TCHAR szAppName [] = TEXT ("Pipes") ;
TCHAR szTitle   [] = TEXT ("Pipes: Palette Animation Demo") ;

static LOGPALETTE * plp ;

HPALETTE CreateRoutine (HWND hwnd)
{
     	HPALETTE 		hPalette ;
     	int  			i ;

     	plp = malloc (sizeof (LOGPALETTE) + 32 * sizeof (PALETTEENTRY)) ;
          				// Initialize the fields of the LOGPALETTE structure
     	plp->palVersion    	= 0x300 ;
     	plp->palNumEntries 	= 16 ;

     	for (i = 0 ; i <= 8 ; i++)
	{
          			plp->palPalEntry[i].peRed   	= (BYTE) min (255, 0x20 * i) ;
          			plp->palPalEntry[i].peGreen 	= 0 ;
          			plp->palPalEntry[i].peBlue  	= (BYTE) min (255, 0x20 * i) ;
          			plp->palPalEntry[i].peFlags 	= PC_RESERVED ;

          			plp->palPalEntry[16 - i] 	= plp->palPalEntry[i] ;
          			plp->palPalEntry[16 + i] 	= plp->palPalEntry[i] ;
          			plp->palPalEntry[32 - i] 	= plp->palPalEntry[i] ;
     	}

     	hPalette = CreatePalette (plp) ;
     	SetTimer (hwnd, ID_TIMER, 100, NULL) ;
     	return hPalette ;
}

void PaintRoutine (HDC hdc, int cxClient, int cyClient)
{
     	HBRUSH 	hBrush ;
     	int    		i ;
     	RECT   		rect ;

          					// Draw window background

     	SetRect (&rect, 0, 0, cxClient, cyClient) ;
     	hBrush = SelectObject (hdc, GetStockObject (WHITE_BRUSH)) ;
     	FillRect (hdc, &rect, hBrush) ;

          					// Draw the interiors of the pipes
     	for (i = 0 ; i < 128 ; i++)
     	{
          			hBrush = CreateSolidBrush (PALETTEINDEX (i % 16)) ;
          			SelectObject (hdc, hBrush) ;

          			rect.left   		= (127 - i) * cxClient / 128 ;
          			zrect.right  		= (128 - i) * cxClient / 128 ;
          			rect.top    		= 4 * cyClient / 14 ;
          			rect.bottom 		= 5 * cyClient / 14 ;

          			FillRect (hdc, &rect, hBrush) ;

          			rect.left   		=  	i * cxClient / 128 ;
          			rect.right  		= (	i + 1) 	* cxClient / 128 ;
          			rect.top    		=  	9 	* cyClient / 14 ;
          			rect.bottom 		= 	10 	* cyClient / 14 ;

          			FillRect (hdc, &rect, hBrush) ;

          		DeleteObject (SelectObject (hdc, GetStockObject (WHITE_BRUSH))) ;
     }

          					// Draw the edges of the pipes
     	MoveToEx 		(hdc, 0,  4 * cyClient / 14, NULL) ;
     	LineTo   		(hdc, cxClient,  4 	* cyClient / 14) ;

     	MoveToEx 		(hdc, 0,  5 * cyClient / 14, NULL) ;
     	LineTo   		(hdc, cxClient,	5 	* cyClient / 14) ;

     	MoveToEx 		(hdc, 0,  9	* cyClient / 14, NULL) ;
     	LineTo   		(hdc, cxClient, 9 * cyClient / 14) ;

     	MoveToEx 		(hdc, 0,  10 * cyClient / 14, NULL) ;
     	LineTo   (hdc, cxClient, 		10 * cyClient / 14) ;
     	return ;
}

void TimerRoutine (HDC hdc, HPALETTE hPalette)
{
     	static int iIndex ;
     	AnimatePalette (hPalette, 0, 16, plp->palPalEntry + iIndex) ;
     	iIndex = (iIndex + 1) % 16 ;

     	return ;
}

void DestroyRoutine (HWND hwnd, HPALETTE hPalette)
{
     	KillTimer (hwnd, ID_TIMER) ;
     	DeleteObject (hPalette) ;
     	free (plp) ;
     	return ;
}

 ï¿½ï¿½Ê½16-11  TUNNEL
TUNNEL.C
/*---------------------------------------------------------------------------
   	TUNNEL.C -- 	Palette Animation Demo
               						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#define ID_TIMER 1
TCHAR szAppName 	[] = TEXT ("Tunnel") ;
TCHAR szTitle   	[] = TEXT ("Tunnel: Palette Animation Demo") ;

static LOGPALETTE * plp ;
HPALETTE CreateRoutine (HWND hwnd)
{
     	BYTE     		byGrayLevel ;
     	HPALETTE 		hPalette ;
     	int      		i ;

     	plp = malloc (sizeof (LOGPALETTE) + 255 * sizeof (PALETTEENTRY)) ;
          			// Initialize the fields of the LOGPALETTE structure
     	plp->palVersion    	= 0x0300 ;
     	plp->palNumEntries 	= 128 ;
     
     	for (i = 0 ; i < 128 ; i++)
     	{
          			if (i < 64)
               					byGrayLevel = (BYTE) (4 * i) ;
          			else
               					byGrayLevel = (BYTE) min (255, 4 * (128 - i)) ;
          			plp->palPalEntry[i].peRed 	= byGrayLevel ;
          			plp->palPalEntry[i].peGreen	= byGrayLevel ;
          			plp->palPalEntry[i].peBlue	= byGrayLevel ;
          			plp->palPalEntry[i].peFlags	= PC_RESERVED ;
          
          			plp->palPalEntry[i + 128].peRed 	 = byGrayLevel ;
          			plp->palPalEntry[i + 128].peGreen = byGrayLevel ;
          			plp->palPalEntry[i + 128].peBlue  = byGrayLevel ;
          			plp->palPalEntry[i + 128].peFlags = PC_RESERVED ;
     	}
   
     	hPalette = CreatePalette (plp) ;
     	SetTimer (hwnd, ID_TIMER, 50, NULL) ;
     	return hPalette ;
}

void PaintRoutine (HDC hdc, int cxClient, int cyClient)
{
     	HBRUSH 	hBrush ;
     	int    		i ;
     	RECT   		rect ;
     
     	for (i = 0 ; i < 127 ; i++)
     {
               				// Use a RECT structure for each of 128 rectangles
      			rect.left   =   i * cxClient / 255 ;
       			rect.top    =   i * cyClient / 255 ;
          			rect.right  = cxClient - i * cxClient / 255 ;
          			rect.bottom = cyClient - i * cyClient / 255 ;
          
          			hBrush = CreateSolidBrush (PALETTEINDEX (i)) ;
               				// Fill the rectangle and delete the brush
          
          			FillRect (hdc, &rect, hBrush) ;
          			DeleteObject (hBrush) ;
     	}
     	return ;
}

void TimerRoutine (HDC hdc, HPALETTE hPalette)
{
     	static int iLevel ;
     	iLevel = (iLevel + 1) % 128 ;
     	AnimatePalette (hPalette, 0, 128, plp->palPalEntry + iLevel) ;
     	return ;
}

void DestroyRoutine (HWND hwnd, HPALETTE hPalette)
{
     	KillTimer (hwnd, ID_TIMER) ;
     	DeleteObject (hPalette) ;
     	free (plp) ;
     	return ;
}

 ï¿½ï¿½Ê½16-12  PACKEDIB����
PACKEDIB.H
/*-------------------------------------------------------------------------
   PACKEDIB.H -- 	Header file for PACKEDIB.C
          							(c) Charles Petzold, 1998
--------------------------------------------------------------------------*/

#include <windows.h>

BITMAPINFO * PackedDibLoad (PTSTR szFileName) ;
int PackedDibGetWidth (BITMAPINFO * pPackedDib) ;
int PackedDibGetHeight (BITMAPINFO * pPackedDib) ;
int PackedDibGetBitCount (BITMAPINFO * pPackedDib) ;
int PackedDibGetRowLength (BITMAPINFO * pPackedDib) ;
int PackedDibGetInfoHeaderSize (BITMAPINFO * pPackedDib) ;
int PackedDibGetColorsUsed (BITMAPINFO * pPackedDib) ;
int PackedDibGetNumColors (BITMAPINFO * pPackedDib) ;
int PackedDibGetColorTableSize (BITMAPINFO * pPackedDib) ;
RGBQUAD * PackedDibGetColorTablePtr (BITMAPINFO * pPackedDib) ;
RGBQUAD * PackedDibGetColorTableEntry (BITMAPINFO * pPackedDib, int i) ;
BYTE * PackedDibGetBitsPtr (BITMAPINFO * pPackedDib) ;
int PackedDibGetBitsSize (BITMAPINFO * pPackedDib) ;
HPALETTE PackedDibCreatePalette (BITMAPINFO * pPackedDib) ;

PACKEDIB.C
/*-------------------------------------------------------------------------
   	PACKEDIB.C -- 		Routines for using packed DIBs
                 							(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>

/*---------------------------------------------------------------------------
   	PackedDibLoad: Load DIB File as Packed-Dib Memory Block
----------------------------------------------------------------------------*/

BITMAPINFO * PackedDibLoad (PTSTR szFileName)
{
     	BITMAPFILEHEADER 		bmfh ;
     	BITMAPINFO     			*	pbmi ;
     	BOOL             		bSuccess ;
     	DWORD            		dwPackedDibSize, dwBytesRead ;
     	HANDLE           		hFile ;
          		// Open the file: read access, prohibit write access

     	hFile = CreateFile (szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, 
        OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL) ;
     	if (hFile == INVALID_HANDLE_VALUE)
          			return NULL ;
  			// Read in the BITMAPFILEHEADER
     	bSuccess = ReadFile (	hFile, &bmfh, sizeof (BITMAPFILEHEADER), 
                          	&dwBytesRead, NULL) ;

     	if (!bSuccess 	|| (dwBytesRead != sizeof (BITMAPFILEHEADER))         
                   		|| (bmfh.bfType != * (WORD *) "BM"))
     	{
          			CloseHandle (hFile) ;
          			return NULL ;
     	}

          			// Allocate memory for the packed DIB & read it in
     	dwPackedDibSize = bmfh.bfSize - sizeof (BITMAPFILEHEADER) ;
     	pbmi = malloc (dwPackedDibSize) ;
  	bSuccess = ReadFile (hFile, pbmi, dwPackedDibSize, &dwBytesRead, NULL) ;
     	CloseHandle (hFile) ;

     	if (!bSuccess || (dwBytesRead != dwPackedDibSize))
     	{
          			free (pbmi) ;
          			return NULL ;
     	}

     	return pbmi ;
}

/*--------------------------------------------------------------------------
   Functions to get information from packed DIB
----------------------------------------------------------------------------*/

int PackedDibGetWidth (BITMAPINFO * pPackedDib)
{
     	if (pPackedDib->bmiHeader.biSize == sizeof (BITMAPCOREHEADER))
          			return ((PBITMAPCOREINFO)pPackedDib)->bmciHeader.bcWidth ;
     	else
          			return pPackedDib->bmiHeader.biWidth ;
}

int PackedDibGetHeight (BITMAPINFO * pPackedDib)
{
    	if (pPackedDib->bmiHeader.biSize == sizeof (BITMAPCOREHEADER))
          			return ((PBITMAPCOREINFO)pPackedDib)->bmciHeader.bcHeight ;
     	else
          			return abs (pPackedDib->bmiHeader.biHeight) ;
}

int PackedDibGetBitCount (BITMAPINFO * pPackedDib)
{
     	if (pPackedDib->bmiHeader.biSize == sizeof (BITMAPCOREHEADER))
          			return ((PBITMAPCOREINFO)pPackedDib)->bmciHeader.bcBitCount ;
     	else
          			return pPackedDib->bmiHeader.biBitCount ;
}

int PackedDibGetRowLength (BITMAPINFO * pPackedDib)
{
     	return ((	PackedDibGetWidth (pPackedDib) * 
              					PackedDibGetBitCount (pPackedDib) + 31) & ~31) >> 3 ;
}

/*---------------------------------------------------------------------------
   	PackedDibGetInfoHeaderSize includes possible color masks!
----------------------------------------------------------------------------*/

int PackedDibGetInfoHeaderSize (BITMAPINFO * pPackedDib)
{
     	if (	pPackedDib->bmiHeader.biSize == sizeof (BITMAPCOREHEADER))
         		 	return ((PBITMAPCOREINFO)pPackedDib)->bmciHeader.bcSize ;

     	else 	if (pPackedDib->bmiHeader.biSize == sizeof (BITMAPINFOHEADER))
          			return pPackedDib->bmiHeader.biSize + 
                    (pPackedDib->bmiHeader.biCompression == 
                     BI_BITFIELDS ? 12 : 0) ;
     	else return pPackedDib->bmiHeader.biSize ;
}

/*--------------------------------------------------------------------------
   	PackedDibGetColorsUsed returns value in information header;
          			could be 0 to indicate non-truncated color table!
----------------------------------------------------------------------------*/

int PackedDibGetColorsUsed (BITMAPINFO * pPackedDib)
{
     	if (pPackedDib->bmiHeader.biSize == sizeof (BITMAPCOREHEADER))
          			return 0 ;
     	else
          			return pPackedDib->bmiHeader.biClrUsed ;
}

/*----------------------------------------------------------------------------
   	PackedDibGetNumColors is actual number of entries in color table
-----------------------------------------------------------------------------*/

int PackedDibGetNumColors (BITMAPINFO * pPackedDib)
{
     	int iNumColors ;
     	iNumColors = PackedDibGetColorsUsed (pPackedDib) ;
     	if (	iNumColors == 	0 && PackedDibGetBitCount (pPackedDib) < 16)
          			 iNumColors =1 << PackedDibGetBitCount (pPackedDib) ;

     	return iNumColors ;
}

int PackedDibGetColorTableSize (BITMAPINFO * pPackedDib)
{
     	if (pPackedDib->bmiHeader.biSize == sizeof (BITMAPCOREHEADER))
          			return PackedDibGetNumColors (pPackedDib) * sizeof (RGBTRIPLE) ;
     	else
          			return PackedDibGetNumColors (pPackedDib) * sizeof (RGBQUAD) ;
}

RGBQUAD * PackedDibGetColorTablePtr (BITMAPINFO * pPackedDib)
{
	if (PackedDibGetNumColors (pPackedDib) == 0)
          			return 0 ;
     	return (RGBQUAD *) (((BYTE *)	pPackedDib) + 
                            PackedDibGetInfoHeaderSize (pPackedDib)) ;
}

RGBQUAD * PackedDibGetColorTableEntry (BITMAPINFO * pPackedDib, int i)
{
     	if 	(	PackedDibGetNumColors (pPackedDib) == 0)
          			return 0 ;

     	if 	(	pPackedDib->bmiHeader.biSize == sizeof (BITMAPCOREHEADER))
          			return (RGBQUAD *) 
               				(((RGBTRIPLE *) PackedDibGetColorTablePtr (pPackedDib)) + i) ;
     	else
          		return PackedDibGetColorTablePtr (pPackedDib) + i ;
}

/*--------------------------------------------------------------------------
   PackedDibGetBitsPtr finally!
----------------------------------------------------------------------------*/

BYTE * PackedDibGetBitsPtr (BITMAPINFO * pPackedDib)
{
     	return ((BYTE *) pPackedDib)+	PackedDibGetInfoHeaderSize (pPackedDib) +
                                        PackedDibGetColorTableSize (pPackedDib) ;
}

/*----------------------------------------------------------------------------- 
   	PackedDibGetBitsSize can be calculated from the height and row length
          		if it's not explicitly in the biSizeImage field
-----------------------------------------------------------------------------*/

int PackedDibGetBitsSize (BITMAPINFO * pPackedDib)
{
     		if ((pPackedDib->bmiHeader.biSize != sizeof (BITMAPCOREHEADER)) &&
         				(pPackedDib->bmiHeader.biSizeImage != 0))
         				return pPackedDib->bmiHeader.biSizeImage ;

     		return 	PackedDibGetHeight (pPackedDib) * 
            					PackedDibGetRowLength (pPackedDib) ;
}

/*---------------------------------------------------------------------------
   PackedDibCreatePalette creates logical palette from PackedDib
-----------------------------------------------------------------------------*/
HPALETTE PackedDibCreatePalette (BITMAPINFO * pPackedDib)
{
     	HPALETTE   hPalette ;
     	int        i, iNumColors ;
     	LOGPALETTE 	* 	plp ;
     	RGBQUAD    * 	prgb ;

     	if (0 == ( iNumColors = PackedDibGetNumColors (pPackedDib)))
  			return NULL ;
     	plp = malloc (sizeof 	(LOGPALETTE) * 
        (iNumColors - 1) * sizeof (PALETTEENTRY)) ;

     	plp->palVersion    = 0x0300 ;
     	plp->palNumEntries = iNumColors ;
     	for (i = 0 ; i < iNumColors ; i++)
     	{
          			prgb = PackedDibGetColorTableEntry (pPackedDib, i) ;
          			plp->palPalEntry[i].peRed   	= prgb->rgbRed ;
          			plp->palPalEntry[i].peGreen 	= prgb->rgbGreen ;
          			plp->palPalEntry[i].peBlue  	= prgb->rgbBlue ;
          			plp->palPalEntry[i].peFlags 	= 0 ;
     	}

     	hPalette = CreatePalette (plp) ;
     	free (plp) ;

     	return hPalette ;
}

dwPixel = PackedDibGetPixel (pPackedDib, x, y) ;

 ï¿½ï¿½Ê½16-13  SHOWDIB3
SHOWDIB3.C
/*--------------------------------------------------------------------------
   	SHOWDIB3.C -- 		Displays DIB with native palette
                 							(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "PackeDib.h"
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("ShowDib3") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    	PSTR szCmdLine, int iCmdShow)
{
     	HWND     	hwnd ;
     	MSG      	msg ;
     	WNDCLASS 	wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;
     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      				szAppName, MB_ICONERROR) ;
         	 		return 0 ;
     }

     	hwnd = CreateWindow (	szAppName, TEXT ("Show DIB #3: Native Palette"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT, 
                          	NULL, NULL, hInstance, NULL) ;
	
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

 	while (GetMessage (&msg, NULL, 0, 0))
     	{
			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
   	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static BITMAPINFO *	pPackedDib ;
     	static HPALETTE     			hPalette ;
     	static int          			cxClient, cyClient ;
     	static OPENFILENAME 	ofn ;
     	static TCHAR        	szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static TCHAR        	szFilter[] = 	TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
        TEXT ("All Files (*.*)\0*.*\0\0") ;
     	HDC                 					hdc ;
     	PAINTSTRUCT         					ps ;

     	switch (message)
     	{
     	case 	WM_CREATE:
          			ofn.lStructSize       		= sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         		= hwnd ;
          			ofn.hInstance         		= NULL ;
          			ofn.lpstrFilter      		= szFilter ;
          			ofn.lpstrCustomFilter 		= NULL ;
          			ofn.nMaxCustFilter    		= 0 ;
          			ofn.nFilterIndex      		= 0 ;
          			ofn.lpstrFile         		= szFileName ;
          			ofn.nMaxFile          		= MAX_PATH ;
          			ofn.lpstrFileTitle    		= szTitleName ;
          			ofn.nMaxFileTitle     		= MAX_PATH ;
          			ofn.lpstrInitialDir   		= NULL ;
          			ofn.lpstrTitle        		= NULL ;
          			ofn.Flags             		= 0 ;
          			ofn.nFileOffset       		= 0 ;
          			ofn.nFileExtension    		= 0 ;
          			ofn.lpstrDefExt       		= TEXT ("bmp") ;
          			ofn.lCustData         		= 0 ;
          			ofn.lpfnHook          		= NULL ;
          			ofn.lpTemplateName    		= NULL ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case IDM_FILE_OPEN:

                    		// Show the File Open dialog box

               					if (!GetOpenFileName (&ofn))
                    							return 0 ;
               
                    		// If there's an existing packed DIB, free the memory

               					if (pPackedDib)
               					{
                    						free (pPackedDib) ;
                    						pPackedDib = NULL ;
               				}
               
                    		// If there's an existing logical palette, delete it

               					if (hPalette)
               					{
                    							DeleteObject (hPalette) ;
                    							hPalette = NULL ;
               				}
                    							// Load the packed DIB into memory

               						SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               						ShowCursor (TRUE) ;

               						pPackedDib = PackedDibLoad (szFileName) ;

               						ShowCursor (FALSE) ;
               						SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               						if (pPackedDib)
               						{
                         		// Create the palette from the DIB color table

                    			hPalette = PackedDibCreatePalette (pPackedDib) ;
               						}
               						else
               						{
                    MessageBox (	hwnd, TEXT ("Cannot load DIB file"), 
                                    szAppName, 0) ;
               						}
               						InvalidateRect (hwnd, NULL, TRUE) ;
               						return 0 ;
          			}
          			break ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (hPalette)
          			{
               					SelectPalette (hdc, hPalette, FALSE) ;
               					RealizePalette (hdc) ;
          			}
          
          			if (pPackedDib)
               		SetDIBitsToDevice (hdc, 0,0,PackedDibGetWidth (pPackedDib), 
                                  				PackedDibGetHeight (pPackedDib),
                                		0,0,0,PackedDibGetHeight (pPackedDib),  
                                  		      PackedDibGetBitsPtr (pPackedDib), 
                                  			  pPackedDib, 
                    DIB_RGB_COLORS) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hPalette)
               					return FALSE ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;

          
     	case 	WM_DESTROY:
          			if (pPackedDib)
               					free (pPackedDib) ;

          			if (hPalette)
               					DeleteObject (hPalette) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 SHOWDIB3.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
SHOWDIB3 MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
        MENUITEM "&Open",  			IDM_FILE_OPEN
    	END
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by ShowDib3.rc

#define IDM_FILE_OPEN         40001

 ï¿½ï¿½Ê½16-14  SHOWDIB4
SHOWDIB4.C
/*---------------------------------------------------------------------------
   	SHOWDIB4.C -- 	Displays DIB with "all-purpose" palette
                 						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\ShowDib3\\PackeDib.h"
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("ShowDib4") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    			PSTR szCmdLine, int iCmdShow)
{
     	HWND     			hwnd ;
     	MSG      			msg ;
     	WNDCLASS 		wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;
     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      								szAppName, MB_ICONERROR) ;
        			return 0 ;
     	}
	
     	hwnd = CreateWindow (	szAppName, TEXT ("Show DIB #4: All-Purpose Palette"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT, 
                          	NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
         			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

/*-----------------------------------------------------------------------------
   	CreateAllPurposePalette: Creates a palette suitable for a wide variety
       		of images; the palette has 247 entries, but 15 of them are 
   		duplicates or match the standard 20 colors.
-----------------------------------------------------------------------------*/

HPALETTE CreateAllPurposePalette (void)
{
     	HPALETTE hPalette ;
     	int          				i, incr, R, G, B ;
     	LOGPALETTE * 	plp ;

     	plp = malloc (sizeof (LOGPALETTE) + 246 * sizeof (PALETTEENTRY)) ;
     	plp->palVersion  	= 0x0300 ;
     	plp->palNumEntries 	= 247 ;

       		// The following loop calculates 31 gray shades, but 3 of them
          		//     will match the standard 20 colors

     	for (i = 0, G = 0, incr = 8 ; G <= 0xFF ; i++, G += incr)
     	{
          			plp->palPalEntry[i].peRed 	= (BYTE) G ;
          			plp->palPalEntry[i].peGreen 	= (BYTE) G ;
          			plp->palPalEntry[i].peBlue  	= (BYTE) G ;
          			plp->palPalEntry[i].peFlags 	= 0 ;

          			incr = (incr == 9 ? 8 : 9) ;
     	}

          		// The following loop is responsible for 216 entries, but 8 of 
          		// them will match the standard 20 colors, and another
          		// 4 of them will match the gray shades above.

     	for (R = 0 ; R <= 0xFF ; R += 0x33)
     	for (G = 0 ; G <= 0xFF ; G += 0x33)
     	for (B = 0 ; B <= 0xFF ; B += 0x33)
     {
          			plp->palPalEntry	[i].peRed   	= (BYTE) R ;
          			plp->palPalEntry	[i].peGreen 	= (BYTE) G ;
          			plp->palPalEntry	[i].peBlue  	= (BYTE) B ;
          			plp->palPalEntry	[i].peFlags 	= 0 ;
			
          			i++ ;
     	}
     	hPalette = CreatePalette (plp) ;
     	free (plp) ;
     	return hPalette ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static 	BITMAPINFO * 	pPackedDib ;
     	static 	HPALETTE     			hPalette ;
     	static 	int          				cxClient, cyClient ;
     	static 	OPENFILENAME 	ofn ;
     	static 	TCHAR        szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static 	TCHAR        szFilter[] =	TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
        TEXT ("All Files (*.*)\0*.*\0\0") ;
     	HDC                 							hdc ;
     	PAINTSTRUCT         					ps ;
     	switch (message)
     {
     	case 	WM_CREATE:
          			ofn.lStructSize       		= sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         		= hwnd ;
          			ofn.hInstance         		= NULL ;
          			ofn.lpstrFilter       		= szFilter ;
          			ofn.lpstrCustomFilter 		= NULL ;
          			ofn.nMaxCustFilter    		= 0 ;
          			ofn.nFilterIndex      		= 0 ;
          			ofn.lpstrFile         		= szFileName ;
          			ofn.nMaxFile          		= MAX_PATH ;
          			ofn.lpstrFileTitle    		= szTitleName ;
          			ofn.nMaxFileTitle     		= MAX_PATH ;
          			ofn.lpstrInitialDir   		= NULL ;
          			ofn.lpstrTitle        		= NULL ;
          			ofn.Flags             		= 0 ;
          			ofn.nFileOffset       		= 0 ;
          			ofn.nFileExtension    		= 0 ;
          			ofn.lpstrDefExt       		= TEXT ("bmp") ;
          			ofn.lCustData         		= 0 ;
          			ofn.lpfnHook          		= NULL ;
          			ofn.lpTemplateName    		= NULL ;

               					// Create the All-Purpose Palette

          			hPalette = CreateAllPurposePalette () ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
     			return 0 ;

     	case 	WM_COMMAND:
       	   		switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_OPEN:

                    						// Show the File Open dialog box

               					if (!GetOpenFileName (&ofn))
                    							return 0 ;
               
                    	// If there's an existing packed DIB, free the memory
        					if (pPackedDib)
               					{
                    						free (pPackedDib) ;
                    						pPackedDib = NULL ;
               					}
               
                    						// Load the packed DIB into memory
	
               					SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               					ShowCursor (TRUE) ;

               					pPackedDib = PackedDibLoad (szFileName) ;

               					ShowCursor (FALSE) ;
               					SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               					if (!pPackedDib)
               					{
                    MessageBox (	hwnd, TEXT ("Cannot load DIB file"), 
                    				szAppName, 0) ;
               					}
               					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
          			}
          			break ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (pPackedDib)
          			{
               					SelectPalette (hdc, hPalette, FALSE) ;
               					RealizePalette (hdc) ;
          
       				SetDIBitsToDevice (hdc,0,0,PackedDibGetWidth (pPackedDib), 
  										  PackedDibGetHeight (pPackedDib),
                                  		0,0,0,PackedDibGetHeight (pPackedDib),  
                                  			  PackedDibGetBitsPtr (pPackedDib), 
                                  			  pPackedDib, 
                    DIB_RGB_COLORS) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if ((HWND) wParam != hwnd)

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;
          
     	case 	WM_DESTROY:
          			if (pPackedDib)
               					free (pPackedDib) ;

          			DeleteObject (hPalette) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 SHOWDIB4.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
// Menu
SHOWDIB4 MENU DISCARDABLE 
BEGIN
    	POPUP "&Open"
    	BEGIN
        			MENUITEM "&File",  			IDM_FILE_OPEN
    	END
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by ShowDib4.rc

#define IDM_FILE_OPEN            40001

 ï¿½ï¿½Ê½16-15  SHOWDIB5
SHOWDIB5.C
/*--------------------------------------------------------------------------
   	SHOWDIB5.C -- 	Displays DIB with halftone palette
                 						(c) Charles Petzold, 1998
--------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\ShowDib3\\PackeDib.h"
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("ShowDib5") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HWND     			hwnd ;
     	MSG      			msg ;
     	WNDCLASS 		wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     }

     	hwnd = CreateWindow (	szAppName, TEXT ("Show DIB #5: Halftone Palette"),
                          		WS_OVERLAPPEDWINDOW,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT, 
                          		NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     {
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     }
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static 	BITMAPINFO * 	pPackedDib ;
     	static 	HPALETTE     	hPalette ;
     	static 	int          	cxClient, cyClient ;
     	static 	OPENFILENAME 	ofn ;
     	static 	TCHAR        	szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static 	TCHAR        	szFilter[] =	TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
        TEXT ("All Files (*.*)\0*.*\0\0") ;
     	HDC                 				hdc ;
     	PAINTSTRUCT        					ps ;

     	switch (message)
     {
     	case 	WM_CREATE:
          			ofn.lStructSize       		= sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         		= hwnd ;
          			ofn.hInstance         		= NULL ;
          			ofn.lpstrFilter       		= szFilter ;
          			ofn.lpstrCustomFilter 		= NULL ;
          			ofn.nMaxCustFilter    		= 0 ;
          			ofn.nFilterIndex      		= 0 ;
          			ofn.lpstrFile         		= szFileName ;
          			ofn.nMaxFile          		= MAX_PATH ;
          			ofn.lpstrFileTitle    		= szTitleName ;
          			ofn.nMaxFileTitle     		= MAX_PATH ;
          			ofn.lpstrInitialDir   		= NULL ;
          			ofn.lpstrTitle        		= NULL ;
          			ofn.Flags             		= 0 ;
          			ofn.nFileOffset       		= 0 ;
          			ofn.nFileExtension    		= 0 ;
          			ofn.lpstrDefExt       		= TEXT ("bmp") ;
          			ofn.lCustData         		= 0 ;
          			ofn.lpfnHook          		= NULL ;
          			ofn.lpTemplateName    		= NULL ;

               				// Create the All-Purpose Palette

          			hdc = GetDC (hwnd) ;
          			hPalette = CreateHalftonePalette (hdc) ;
          			ReleaseDC (hwnd, hdc) ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_OPEN:

                    						// Show the File Open dialog box

               					if (!GetOpenFileName (&ofn))
                    							return 0 ;
               
                   	// If there's an existing packed DIB, free the memory

               					if (pPackedDib)
               					{
                    						free (pPackedDib) ;
                    						pPackedDib = NULL ;
               					}
               
                    						// Load the packed DIB into memory

               					SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               					ShowCursor (TRUE) ;

               					pPackedDib = PackedDibLoad (szFileName) ;

               					ShowCursor (FALSE) ;
               					SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               					if (!pPackedDib)
               					{
                   MessageBox (	hwnd, TEXT ("Cannot load DIB file"), 
                                szAppName, 0) ;
               					}
               					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
          			}
          			break ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (pPackedDib)
          			{
                   					// Set halftone stretch mode

               				SetStretchBltMode (hdc, HALFTONE) ;
               				SetBrushOrgEx (hdc, 0, 0, NULL) ;

                    					// Select and realize halftone palette

               				SelectPalette (hdc, hPalette, FALSE) ;
               				RealizePalette (hdc) ;

                    	// StretchDIBits rather than SetDIBitsToDevice
               			StretchDIBits (	hdc,0,0,PackedDibGetWidth (pPackedDib), 
                       					PackedDibGetHeight (pPackedDib),
                              				0,0,PackedDibGetWidth (pPackedDib),
                              				PackedDibGetHeight (pPackedDib),  
                              				PackedDibGetBitsPtr (pPackedDib), 
                              				pPackedDib, 
                    DIB_RGB_COLORS, 
                    SRCCOPY) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if ((HWND) wParam != hwnd)

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;
          
     	case 	WM_DESTROY:
          			if (pPackedDib)
               					free (pPackedDib) ;

          			DeleteObject (hPalette) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 SHOWDIB5.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
SHOWDIB5 MENU DISCARDABLE 
BEGIN
    	POPUP "&Open"
    	BEGIN
        			MENUITEM "&File",  		IDM_FILE_OPEN
    	END
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by ShowDib5.rc

#define IDM_FILE_OPEN            40001

SetStretchBltMode (hdc, HALFTONE) ;
               			SetBrushOrgEx (hdc, x, y, NULL) ;

 ï¿½ï¿½Ê½16-16  SHOWDIB6
SHOWDIB6.C
/*---------------------------------------------------------------------------
   	SHOWDIB6.C -- 	Display DIB with palette indices
                 						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\ShowDib3\\PackeDib.h"
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("ShowDib6") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HWND     			hwnd ;
     	MSG      			msg ;
     	WNDCLASS 		wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     }

     	hwnd = CreateWindow (	szAppName, TEXT ("Show DIB #6: Palette Indices"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT, 
                          	NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
	{
			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static 	BITMAPINFO *	pPackedDib ;
     	static 	HPALETTE     	hPalette ;
     	static 	int          	cxClient, cyClient ;
     	static 	OPENFILENAME 	ofn ;
     	static 	TCHAR        	szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static 	TCHAR        	szFilter[] = 	TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
        TEXT ("All Files (*.*)\0*.*\0\0") ;
     	HDC                 	hdc ;
     	int                 	i, iNumColors ;
     	PAINTSTRUCT        		ps ;
     	WORD              		* 		pwIndex ;

     	switch (message)
     	{
     	case 	WM_CREATE:
          			ofn.lStructSize       		= sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         		= hwnd ;
          			ofn.hInstance         		= NULL ;
          			ofn.lpstrFilter      		= szFilter ;
          			ofn.lpstrCustomFilter 		= NULL ;
          			ofn.nMaxCustFilter    		= 0 ;
          			ofn.nFilterIndex      		= 0 ;
          			ofn.lpstrFile         		= szFileName ;
          			ofn.nMaxFile          		= MAX_PATH ;
          			ofn.lpstrFileTitle    		= szTitleName ;
          			ofn.nMaxFileTitle     		= MAX_PATH ;
          			ofn.lpstrInitialDir   		= NULL ;
          			ofn.lpstrTitle        		= NULL ;
          			ofn.Flags             		= 0 ;
          			ofn.nFileOffset       		= 0 ;
          			ofn.nFileExtension    		= 0 ;
          			ofn.lpstrDefExt       		= TEXT ("bmp") ;
          			ofn.lCustData         		= 0 ;
          			ofn.lpfnHook          		= NULL ;
          			ofn.lpTemplateName    		= NULL ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_OPEN:

                    						// Show the File Open dialog box
               					if (!GetOpenFileName (&ofn))
                    							return 0 ;
               
                    		// If there's an existing packed DIB, free the memory

               			if (pPackedDib)
               			{
                    					free (pPackedDib) ;
                    					pPackedDib = NULL ;
          			}
               
                    	// If there's an existing logical palette, delete it

               			if (hPalette)
               			{
                    					DeleteObject (hPalette) ;
                   	 				hPalette = NULL ;
               			}
               
                    				// Load the packed DIB into memory

               			SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               			ShowCursor (TRUE) ;

               			pPackedDib = PackedDibLoad (szFileName) ;

               			ShowCursor (FALSE) ;
               			SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               			if (pPackedDib)
               			{
                         	// Create the palette from the DIB color table

                    	hPalette = PackedDibCreatePalette (pPackedDib) ;

                         	// Replace DIB color table with indices

                    				if (hPalette)
                    				{
                         	iNumColors = PackedDibGetNumColors (pPackedDib) ;
                         						pwIndex = (WORD *) 
                                        		PackedDibGetColorTablePtr (pPackedDib) ;

                         		for (i = 0 ; i < iNumColors ; i++)
                              							pwIndex[i] = (WORD) i ;
                   	 				}
               				}
               				else
               				{
           MessageBox (	hwnd, TEXT ("Cannot load DIB file"), 
               			szAppName, 0) ;
               				}
               				InvalidateRect (hwnd, NULL, TRUE) ;
               				return 0 ;
          			}
          			break ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (hPalette)
          			{
               					SelectPalette (hdc, hPalette, FALSE) ;
               					RealizePalette (hdc) ;
          			}
          
          			if (pPackedDib)
   					SetDIBitsToDevice (hdc,0,0,PackedDibGetWidth  (pPackedDib), 
                                  		       PackedDibGetHeight (pPackedDib),
                                  		 0,0,0,PackedDibGetHeight (pPackedDib),  
                                  		       PackedDibGetBitsPtr (pPackedDib), 
                                  			   pPackedDib, 
                    DIB_PAL_COLORS) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hPalette)
               					return FALSE ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;

          
     	case 	WM_DESTROY:
          			if (pPackedDib)
               					free (pPackedDib) ;

          			if (hPalette)
               					DeleteObject (hPalette) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 SHOWDIB6.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
SHOWDIB6 MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
        			MENUITEM "&Open", 				IDM_FILE_OPEN
    	END
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by ShowDib6.rc
//
#define IDM_FILE_OPEN           40001

 ï¿½ï¿½Ê½16-17  SHOWDIB7
SHOWDIB7.C
/*--------------------------------------------------------------------------
   	SHOWDIB7.C --	 	Shows DIB converted to DDB 
                 							(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\ShowDib3\\PackeDib.h"
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("ShowDib7") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
    	HWND     			hwnd ;
    	MSG      			msg ;
    	WNDCLASS 		wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     }

     	hwnd = CreateWindow (	szAppName, TEXT ("Show DIB #7: Converted to DDB"),
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT, 
                          NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     }
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static HBITMAP     			hBitmap ;
     	static HPALETTE     		hPalette ;
     	static int          		cxClient, cyClient ;
     	static OPENFILENAME 	    ofn ;
     	static TCHAR        		szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static TCHAR        		szFilter[] = 	TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
        TEXT ("All Files (*.*)\0*.*\0\0") ;
     	BITMAP              		bitmap ;
     	BITMAPINFO        		   *	pPackedDib ;
     	HDC                 		hdc, hdcMem ;
     	PAINTSTRUCT         		ps ;

	switch (message)
     {
     	case	WM_CREATE:
          			ofn.lStructSize       = sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         = hwnd ;
          			ofn.hInstance         = NULL ;
          			ofn.lpstrFilter       = szFilter ;
          			ofn.lpstrCustomFilter = NULL ;
          			ofn.nMaxCustFilter    = 0 ;
          			ofn.nFilterIndex      = 0 ;
          			ofn.lpstrFile         = szFileName ;
          			ofn.nMaxFile          = MAX_PATH ;
          			ofn.lpstrFileTitle    = szTitleName ;
          			ofn.nMaxFileTitle     = MAX_PATH ;
          			ofn.lpstrInitialDir   = NULL ;
          			ofn.lpstrTitle        = NULL ;
          			ofn.Flags             = 0 ;
          			ofn.nFileOffset       = 0 ;
          			ofn.nFileExtension    = 0 ;
          			ofn.lpstrDefExt       = TEXT ("bmp") ;
          			ofn.lCustData         = 0 ;
          			ofn.lpfnHook          = NULL ;
          			ofn.lpTemplateName    = NULL ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case IDM_FILE_OPEN:

                    				// Show the File Open dialog box

               				if (!GetOpenFileName (&ofn))
					return 0 ;
               	
                    // If there's an existing packed DIB, free the memory

			if (hBitmap)
               			{
                    					DeleteObject (hBitmap) ;
                    					hBitmap = NULL ;
          			}
               
                    // If there's an existing logical palette, delete it

			if (hPalette)
               			{
                    					DeleteObject (hPalette) ;
                    					hPalette = NULL ;
               			}
               
                    				// Load the packed DIB into memory

			SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
			ShowCursor (TRUE) ;

               			pPackedDib = PackedDibLoad (szFileName) ;

               			ShowCursor (FALSE) ;
               			SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               			if (pPackedDib)
              	 		{
                        // Create palette from the DIB and select it into DC

                    hPalette = PackedDibCreatePalette (pPackedDib) ;

                    				hdc = GetDC (hwnd) ;
                    
                    				if (hPalette)
                    				{
                         	SelectPalette (hdc, hPalette, FALSE) ;
                         						RealizePalette (hdc) ;
                    					}
                         						// Create the DDB from the DIB
                    hBitmap = CreateDIBitmap(hdc,(PBITMAPINFOHEADER) pPackedDib,
                              CBM_INIT,PackedDibGetBitsPtr (pPackedDib), 
pPackedDib, DIB_RGB_COLORS) ;
                    					ReleaseDC (hwnd, hdc) ;

                         	// Free the packed-DIB memory

                    					free (pPackedDib) ;
               				}
               				else
               				{
                  MessageBox (	hwnd, TEXT ("Cannot load DIB file"), 
                  				szAppName, 0) ;
               }
               					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
          			}
          			break ;
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (hPalette)
          			{
               					SelectPalette (hdc, hPalette, FALSE) ;
               					RealizePalette (hdc) ;
          			}
          			if (hBitmap)
          			{
               					GetObject (hBitmap, sizeof (BITMAP), &bitmap) ;

               					hdcMem = CreateCompatibleDC (hdc) ;
               					SelectObject (hdcMem, hBitmap) ;

               					BitBlt (hdc,0,0,bitmap.bmWidth, bitmap.bmHeight, 
                       					hdcMem,	0,	0,	SRCCOPY) ;

               				DeleteDC (hdcMem) ;
          			}
         			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hPalette)
               					return FALSE ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;

          
     	case 	WM_DESTROY:
          			if (hBitmap)
               					DeleteObject (hBitmap) ;

          			if (hPalette)
               					DeleteObject (hPalette) ;

          					PostQuitMessage (0) ;
          					return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 SHOWDIB7.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
SHOWDIB7 MENU DISCARDABLE 
BEGIN
   	POPUP "&File"
    	BEGIN
        			MENUITEM "&Open",  			IDM_FILE_OPEN
    	END
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by ShowDib7.rc

#define IDM_FILE_OPEN      40001

 ï¿½ï¿½Ê½16-18  SHOWDIB8
SHOWDIB8.C
/*--------------------------------------------------------------------------
   	SHOWDIB8.C -- 		Shows DIB converted to DIB section
                 							(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\ShowDib3\\PackeDib.h"
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("ShowDib8") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HWND     			hwnd ;
     	MSG      			msg ;
     	WNDCLASS 		wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     	}

     	hwnd = CreateWindow (	szAppName, TEXT ("Show DIB #8: DIB Section"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT, 
                          	NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static HBITMAP      			hBitmap ;
     	static HPALETTE     			hPalette ;
     	static int          			cxClient, cyClient ;
     	static OPENFILENAME 	        ofn ;
     	static PBYTE        			pBits ;
     	static TCHAR        			szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static TCHAR        			szFilter[] = 	TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
        TEXT ("All Files (*.*)\0*.*\0\0") ;
     	BITMAP              		bitmap ;
     	BITMAPINFO        			* 	pPackedDib ;
  	    HDC                 		hdc, hdcMem ;
     	PAINTSTRUCT         		ps ;

     	switch (message)
     	{
     	case 	WM_CREATE:
          			ofn.lStructSize       	= sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         	= hwnd ;
          			ofn.hInstance         	= NULL ;
          			ofn.lpstrFilter       	= szFilter ;
          			ofn.lpstrCustomFilter 	= NULL ;
          			ofn.nMaxCustFilter    	= 0 ;
          			ofn.nFilterIndex      	= 0 ;
          			ofn.lpstrFile         	= szFileName ;
          			ofn.nMaxFile          	= MAX_PATH ;
          			ofn.lpstrFileTitle    	= szTitleName ;
          			ofn.nMaxFileTitle     	= MAX_PATH ;
          			ofn.lpstrInitialDir   	= NULL ;
          			ofn.lpstrTitle        	= NULL ;
          			ofn.Flags             	= 0 ;
          			ofn.nFileOffset       	= 0 ;
          			ofn.nFileExtension    	= 0 ;
          			ofn.lpstrDefExt       	= TEXT ("bmp") ;
          			ofn.lCustData         	= 0 ;
          			ofn.lpfnHook          	= NULL ;
          			ofn.lpTemplateName    	= NULL ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_OPEN:

                    					// Show the File Open dialog box

               					if (!GetOpenFileName (&ofn))
                    							return 0 ;
               
                    // If there's an existing packed DIB, free the memory

               					if (hBitmap)
               					{
                    								DeleteObject (hBitmap) ;
                    								hBitmap = NULL ;
               					}

                    // If there's an existing logical palette, delete it

					if (hPalette)
               					{
                    								DeleteObject (hPalette) ;
                    								hPalette = NULL ;
               					}
                    // Load the packed DIB into memory

               					SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               					ShowCursor (TRUE) ;

               					pPackedDib = PackedDibLoad (szFileName) ;

               					ShowCursor (FALSE) ;
               					SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               					if (pPackedDib)
               					{
                         	// Create the DIB section from the DIB

hBitmap = CreateDIBSection (NULL,pPackedDib,DIB_RGB_COLORS,&pBits,NULL, 0) ;

                   // Copy the bits

                   CopyMemory (pBits,	PackedDibGetBitsPtr  (pPackedDib),
                                        PackedDibGetBitsSize (pPackedDib)) ;

                     // Create palette from the DIB

                    hPalette = PackedDibCreatePalette (pPackedDib) ;

                       // Free the packed-DIB memory

                    						free (pPackedDib) ;
               					}
               					else
               					{
                MessageBox (	hwnd, TEXT ("Cannot load DIB file"), 
                            	szAppName, 0) ;
              					 	}
               					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
          			}
          			break ;
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (hPalette)
          			{
               				SelectPalette (hdc, hPalette, FALSE) ;
               				RealizePalette (hdc) ;
          			}
          			if (hBitmap)
          			{
               				GetObject (hBitmap, sizeof (BITMAP), &bitmap) ;

               				hdcMem = CreateCompatibleDC (hdc) ;
               				SelectObject (hdcMem, hBitmap) ;

               	BitBlt (	hdc,    0, 0, bitmap.bmWidth, bitmap.bmHeight, 
                       		hdcMem, 0, 0, SRCCOPY) ;

               				DeleteDC (hdcMem) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hPalette)
               					return FALSE ;

          			hdc = GetDC 		(hwnd) ;
          			SelectPalette 		(hdc, hPalette, FALSE) ;
          			RealizePalette 		(hdc) ;
          			InvalidateRect 		(hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;

          
     	case 	WM_DESTROY:
          			if (hBitmap)
               					DeleteObject (hBitmap) ;

          			if (hPalette)
               					DeleteObject (hPalette) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 SHOWDIB8.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
SHOWDIB8 MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN	
        			MENUITEM "&Open", 			IDM_FILE_OPEN
    	END
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by ShowDib8.rc

#define IDM_FILE_OPEN             40001

typedef void * HDIB ;

typedef struct
{
     	BITMAPINFO 	* 	pPackedDib ;
     	int          				cx, cy, cBitsPerPixel, cBytesPerRow ;
     	BYTE       			* pBits ;
{
DIBSTRUCTURE, * PDIBSTRUCTURE ;

BYTE * DibGetPixelPointer (HDIB hdib, int x, int y)
{
     	PDIBSTRUCTURE pdib = hdib ;
     	return pdib->pBits + 	y * pdib->cBytesPerRow + 
                          			x * pdib->cBitsPerPixel / 8 ;
}

typedef struct
{
     	PBYTE    	* ppRow ;       // array of row pointers
     	int        	iSignature ;  	// = "Dib "
     	HBITMAP    	hBitmap ;     	// handle returned from CreateDIBSection
     	BYTE     	* 	pBits ;     // pointer to bitmap bits
     	DIBSECTION 	ds ;          	// DIBSECTION structure
     	int        	iRShift[3] ;  	// right-shift values for color masks
     	int        	iLShift[3] ;  	// left-shift values for color masks
}
DIBSTRUCT, * PDIBSTRUCT ;

GetObject (hBitmap, sizeof (DIBSECTION), &ds) ;

typedef struct tagDIBSECTION {
    	BITMAP     				dsBm ;
   	BITMAPINFOHEADER 	dsBmih ;
   	DWORD            	dsBitfields[3] ;    // Color masks
    	HANDLE          dshSection ;
    	DWORD           dsOffset ;
}
DIBSECTION, * PDIBSECTION ;

 ï¿½ï¿½Ê½16-19  DIBHELP.C�����ĵ�һ����
DIBHELP.C ����һ���֣� 
/*--------------------------------------------------------------------------
   	DIBHELP.C -- 	DIB Section Helper Routines 
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "dibhelp.h"

#define HDIB_SIGNATURE (* (int *) "Dib ")
typedef struct
{
     	PBYTE    			* 	ppRow ;    // must be first field for macros!
     	int        			iSignature ;
     	HBITMAP    			hBitmap ;
     	BYTE     			* 	pBits ;
     	DIBSECTION 		ds ;
     	int        				iRShift[3] ;
     	int        				iLShift[3] ;
}
DIBSTRUCT, * PDIBSTRUCT ;

/*----------------------------------------------------------------------------
	DibIsValid:  Returns TRUE if hdib points to a valid DIBSTRUCT
-----------------------------------------------------------------------------*/

BOOL DibIsValid (HDIB hdib)
{
     	PDIBSTRUCT pdib = hdib ;
     	if (pdib == NULL)
          			return FALSE ;
     	if (IsBadReadPtr (pdib, sizeof (DIBSTRUCT)))
          			return FALSE ;
     	if (pdib->iSignature != HDIB_SIGNATURE)
          			return FALSE ;
     	return TRUE ;
}

/*----------------------------------------------------------------------------
   	DibBitmapHandle:	Returns the handle to the DIB section bitmap object
-----------------------------------------------------------------------------*/

HBITMAP DibBitmapHandle (HDIB hdib)
{
     	if (!DibIsValid (hdib))
          			return NULL ;
     	return ((PDIBSTRUCT) hdib)->hBitmap ;
}

/*---------------------------------------------------------------------------
   	DibWidth:  Returns the bitmap pixel width
-----------------------------------------------------------------------------*/

int DibWidth (HDIB hdib)
{
     	if (!DibIsValid (hdib))
          			return 0 ;
     	return ((PDIBSTRUCT) hdib)->ds.dsBm.bmWidth ;
}

/*---------------------------------------------------------------------------
   	DibHeight:  Returns the bitmap pixel height
----------------------------------------------------------------------------*/

int DibHeight (HDIB hdib)
{
 	if (!DibIsValid (hdib))
          			return 0 ; 
     	return ((PDIBSTRUCT) hdib)->ds.dsBm.bmHeight ;
}

/*---------------------------------------------------------------------------
   DibBitCount:  	Returns the number of bits per pixel
----------------------------------------------------------------------------*/

int DibBitCount (HDIB hdib)
{
     	if (!DibIsValid (hdib))
          			return 0 ;
     
     	return ((PDIBSTRUCT) hdib)->ds.dsBm.bmBitsPixel ;
}

/*----------------------------------------------------------------------------
   	DibRowLength:  	Returns the number of bytes per row of pixels
-----------------------------------------------------------------------------*/

int DibRowLength (HDIB hdib)
{
   	if (!DibIsValid (hdib))
          			return 0 ;
     	return 4 * ((DibWidth (hdib) * DibBitCount (hdib) + 31) / 32) ;
}

/*---------------------------------------------------------------------------
   DibNumColors:  	Returns the number of colors in the color table
----------------------------------------------------------------------------*/

int DibNumColors (HDIB hdib)
{
     	PDIBSTRUCT pdib = hdib ;

     	if (!DibIsValid (hdib))
          			return 0 ;

     	if (pdib->ds.dsBmih.biClrUsed != 0)
     {
          			return pdib->ds.dsBmih.biClrUsed ;
     }
     	else if (DibBitCount (hdib) <= 8)
     {
          		return 1 << DibBitCount (hdib) ;
     }
     	return 0 ;
}
/*---------------------------------------------------------------------------
   	DibMask:  Returns one of the color masks
---------------------------------------------------------------------------*/

DWORD 	DibMask (HDIB hdib, int i)
{
     	PDIBSTRUCT pdib = hdib ;

     	if (!DibIsValid (hdib) || i < 0 || i > 2)
          			return 0 ;
     
     	return pdib->ds.dsBitfields[i] ;
}

/*----------------------------------------------------------------------------
   	DibRShift:  Returns one of the right-shift values
-----------------------------------------------------------------------------*/

int 	DibRShift (HDIB hdib, int i)
{	
     	PDIBSTRUCT pdib = hdib ;

     	if (!DibIsValid (hdib) || i < 0 || i > 2)
          			return 0 ;
     
     	return pdib->iRShift[i] ;
}

/*----------------------------------------------------------------------------
   	DibLShift:  Returns one of the left-shift values
----------------------------------------------------------------------------*/

int DibLShift (HDIB hdib, int i)
{
     	PDIBSTRUCT pdib = hdib ;

     	if (!DibIsValid (hdib) || i < 0 || i > 2)
          			return 0 ;
     
     	return pdib->iLShift[i] ;
}

/*---------------------------------------------------------------------------
   	DibCompression:  Returns the value of the biCompression field
----------------------------------------------------------------------------*/
int DibCompression (HDIB hdib)
{
     	if (!DibIsValid (hdib))
          			return 0 ;

     	return ((PDIBSTRUCT) hdib)->ds.dsBmih.biCompression ;
}

/*---------------------------------------------------------------------------
   	DibIsAddressable:  Returns TRUE if the DIB is not compressed
----------------------------------------------------------------------------*/

BOOL 	DibIsAddressable (HDIB hdib)
{
     	int iCompression ;

     	if (!DibIsValid (hdib))
          			return FALSE ;

     	iCompression = DibCompression (hdib) ;

     	if (	iCompression == BI_RGB || iCompression == BI_BITFIELDS)
         			return TRUE ;

     	return FALSE ;
}

/*---------------------------------------------------------------------------
   	These functions return the sizes of various components of the DIB section
     	AS THEY WOULD APPEAR in a packed DIB. These functions aid in converting
	the DIB section to a packed DIB and in saving DIB files.
-----------------------------------------------------------------------------*/

DWORD DibInfoHeaderSize (HDIB hdib)
{
     	if (!DibIsValid (hdib))
          			return 0 ;
     	return ((PDIBSTRUCT) hdib)->ds.dsBmih.biSize ;
}

DWORD 	DibMaskSize (HDIB hdib)
{
     	PDIBSTRUCT pdib = hdib ;
     	if (!DibIsValid (hdib))
          			return 0 ;

	if (pdib->ds.dsBmih.biCompression == BI_BITFIELDS)
          			return 3 * sizeof (DWORD) ;

     	return 0 ;
}

DWORD DibColorSize (HDIB hdib)
{
	return DibNumColors (hdib) * sizeof (RGBQUAD) ;
} 

DWORD DibInfoSize (HDIB hdib)
{
     	return DibInfoHeaderSize(hdib) + DibMaskSize(hdib) + DibColorSize(hdib) ;
}

DWORD DibBitsSize (HDIB hdib)
{
     	PDIBSTRUCT pdib = hdib ;

     	if (!DibIsValid (hdib))
          			return 0 ;

     	if (pdib->ds.dsBmih.biSizeImage != 0)
     {
          			return pdib->ds.dsBmih.biSizeImage ;
     }
     	return DibHeight (hdib) * DibRowLength (hdib) ;
}

DWORD DibTotalSize (HDIB hdib)
{
     	return DibInfoSize (hdib) + DibBitsSize (hdib) ;
}

/*---------------------------------------------------------------------------
   	These functions return pointers to the various components of the DIB 
     	section.
-----------------------------------------------------------------------------*/
BITMAPINFOHEADER * DibInfoHeaderPtr (HDIB hdib)
{
     	if (!DibIsValid (hdib))
          			return NULL ;
     	return & (((PDIBSTRUCT) hdib)->ds.dsBmih) ;
}

DWORD * DibMaskPtr (HDIB hdib)
{
     	PDIBSTRUCT pdib = hdib ;
     	if (!DibIsValid (hdib))
         			return 0 ;
     	return pdib->ds.dsBitfields ;
}

void * DibBitsPtr (HDIB hdib)
{
     	if (!DibIsValid (hdib))
          			return NULL ;
     	return ((PDIBSTRUCT) hdib)->pBits ;
}

/*---------------------------------------------------------------------------
   	DibSetColor:  Obtains entry from the DIB color table
-----------------------------------------------------------------------------*/

BOOL DibGetColor (HDIB hdib, int index, RGBQUAD * prgb)
{
     	PDIBSTRUCT pdib = hdib ;
     	HDC        				hdcMem ;
     	int        				iReturn ;

     	if (!DibIsValid (hdib))
          			return 0 ;
     	hdcMem = CreateCompatibleDC (NULL) ;
     	SelectObject (hdcMem, pdib->hBitmap) ;
     	iReturn = GetDIBColorTable (hdcMem, index, 1, prgb) ;
     	DeleteDC (hdcMem) ;
     	return iReturn ? TRUE : FALSE ;
}

/*----------------------------------------------------------------------------
   	DibGetColor:  Sets an entry in the DIB color table
----------------------------------------------------------------------------*/
 
BOOL DibSetColor (HDIB hdib, int index, RGBQUAD * prgb)
{
     	PDIBSTRUCT 	pdib = hdib ;
     	HDC        			hdcMem ;
     	int        			iReturn ;

     	if (!DibIsValid (hdib))
          			return 0 ;
     	hdcMem = CreateCompatibleDC (NULL) ;
     	SelectObject (hdcMem, pdib->hBitmap) ;
     	iReturn = SetDIBColorTable (hdcMem, index, 1, prgb) ;
     	DeleteDC (hdcMem) ;

     	return iReturn ? TRUE : FALSE ;
}

 ï¿½ï¿½Ê½16-20  DIBHELP.C�����ĵڶ�����
DIBHELP.C ���ڶ����֣� 
/*----------------------------------------------------------------------------
   	DibPixelPtr:  	Returns a pointer to the pixel at position (x, y)
-----------------------------------------------------------------------------*/

BYTE * DibPixelPtr (HDIB hdib, int x, int y)
{
     	if (!DibIsAddressable (hdib))
          			return NULL ;
     	if (x < 0 || x >= DibWidth (hdib) || y < 0 || y >= DibHeight (hdib))
          			return NULL ;
     	return (((PDIBSTRUCT) hdib)->ppRow)[y] + (x * DibBitCount (hdib) >> 3) ;
}

/*---------------------------------------------------------------------------
   	DibGetPixel:  Obtains a pixel value at (x, y)
-----------------------------------------------------------------------------*/

DWORD DibGetPixel (HDIB hdib, int x, int y)
{
     	PBYTE pPixel ;
     	if (!(pPixel = DibPixelPtr (hdib, x, y)))
     			return 0 ;
     	switch (DibBitCount (hdib))
     	{
     	case 		1:  return 0x01 & (* pPixel >> (7 - (x & 7))) ;
     	case		4:  return 0x0F & (* pPixel >> (x & 1 ? 0 : 4)) ;
     	case  		8:  return * pPixel ;
     	case 		16: return * (WORD *) pPixel ;
     	case 		24: return 0x00FFFFFF & * (DWORD *) pPixel ; 
     	case 		32: return * (DWORD *) pPixel ;
     	}
  	return 0 ;
}

/*-------------------------------------------------------------------------
   	DibSetPixel:  Sets a pixel value at (x, y)
---------------------------------------------------------------------------*/

BOOL DibSetPixel (HDIB hdib, int x, int y, DWORD dwPixel)
{
     	PBYTE pPixel ;
     	if (!(pPixel = DibPixelPtr (hdib, x, y)))
          			return FALSE ;
     	switch (DibBitCount (hdib))
     {
     	case  1:  	* 	pPixel &= ~(1     << (7 - (x & 7))) ;
               		* 	pPixel |= dwPixel 	  << (7 - (x & 7)) ;
               					break ;
     	case  	4:  * 	pPixel &= 0x0F    << (x & 1 ? 4 : 0) ;
               		* 	pPixel |= dwPixel 	  << (x & 1 ? 0 : 4) ;
               					break ;
     	case 8:  	* 	pPixel = (BYTE) dwPixel ;
               					break ;

     	case 16:  	* 	(WORD *) pPixel = (WORD) dwPixel ;
               					break ;

     	case 24:  	* 	(RGBTRIPLE *) pPixel = * (RGBTRIPLE *) &dwPixel ; 
               					break ;

     	case 32:  	* 	(DWORD *) pPixel = dwPixel ;
               					break ;
     	default:
          			return FALSE ;
     	}
     	return TRUE ;
}

/*---------------------------------------------------------------------------
   	DibGetPixelColor:  Obtains the pixel color at (x, y)
----------------------------------------------------------------------------*/

BOOL DibGetPixelColor (HDIB hdib, int x, int y, RGBQUAD * prgb)
{
     	DWORD      			dwPixel ;
     	int        			iBitCount ;
     	PDIBSTRUCT 	pdib = hdib ;

          			// Get bit count; also use this as a validity check

     	if (0 == (iBitCount = DibBitCount (hdib)))
          			return FALSE ;
          			// Get the pixel value
     	dwPixel = DibGetPixel (hdib, x, y) ;
          			// If the bit-count is 8 or less, index the color table
     	if (iBitCount <= 8)
          			return DibGetColor (hdib, (int) dwPixel, prgb) ;
          			// If the bit-count is 24, just use the pixel
     	else 	if (iBitCount == 24)
     {
          		* 	(RGBTRIPLE *) prgb = * (RGBTRIPLE *) & dwPixel ;
          			prgb->rgbReserved = 0 ;
 	}

          		// If the bit-count is 32 and the biCompression field is BI_RGB,
          		//   just use the pixel

     	else 	if (iBitCount == 32 && 
               					pdib->ds.dsBmih.biCompression == BI_RGB)
     	{
          		* 	prgb = * (RGBQUAD *) & dwPixel ;
     	}

          		// Otherwise, use the mask and shift values
          		//   (for best performance, don't use DibMask and DibShift functions)
     	else
     	{
          	prgb->rgbRed = (BYTE)(((pdib->ds.dsBitfields[0] & dwPixel) 
                     >> pdib->iRShift[0]) << pdib->iLShift[0]) ;

          	prgb->rgbGreen=(BYTE((pdib->ds.dsBitfields[1] & dwPixel) 
                     >> pdib->iRShift[1]) << pdib->iLShift[1]) ;

          	prgb->rgbBlue=(BYTE)(((pdib->ds.dsBitfields[2] & dwPixel) 
                     >> pdib->iRShift[2]) << pdib->iLShift[2]) ;
     	}
    	return TRUE ;
}

/*-----------------------------------------------------------------------------
   	DibSetPixelColor:  Sets the pixel color at (x, y) 
-----------------------------------------------------------------------------*/

BOOL DibSetPixelColor (HDIB hdib, int x, int y, RGBQUAD * prgb)
{
     	DWORD      			dwPixel ;
     	int        			iBitCount ;
     	PDIBSTRUCT 	pdib = hdib ;

          		// Don't do this function for DIBs with color tables

     	iBitCount = DibBitCount (hdib) ;
     	if (iBitCount <= 8)
          			return FALSE ;
          		// The rest is just the opposite of DibGetPixelColor
     	else if (iBitCount == 24)
     	{
          			* (RGBTRIPLE *) & dwPixel = * (RGBTRIPLE *) prgb ;
       			dwPixel &= 0x00FFFFFF ;
     	}
     	else if (iBitCount == 32 &&
               					pdib->ds.dsBmih.biCompression == BI_RGB)
     {
          			* (RGBQUAD *) & dwPixel = * prgb ;
     }

     	else
     {
        dwPixel  = 	(((DWORD)	prgb->rgbRed >> pdib->iLShift[0]) 
        << pdib->iRShift[0]) ; 

        dwPixel |= 	(((DWORD) 	prgb->rgbGreen >> pdib->iLShift[1])
        << pdib->iRShift[1]) ; 

        dwPixel |= 	(((DWORD) 	prgb->rgbBlue >> pdib->iLShift[2])
        << pdib->iRShift[2]) ; 
     	}

     	DibSetPixel (hdib, x, y, dwPixel) ;
     	return TRUE ;
}

((PDIBSTRUCT) hdib)->pprow)[0]

(((PDIBSTRUCT) hdib)->ppRow)[y] + (x * DibBitCount (hdib) >> 3)

 ï¿½ï¿½Ê½16-21  DIBHELP.C�����ĵ������ֺ����Ჿ��
DIBHELP.C ���������֣� 
/*--------------------------------------------------------------------------
	Calculating shift values from color masks is required by the 
	DibCreateFromInfo function.
----------------------------------------------------------------------------*/

static int MaskToRShift (DWORD dwMask)
{
     	int iShift ;
     	if (dwMask == 0)
          			return 0 ;
     	for (iShift = 0 ; !(dwMask & 1) ; iShift++)
          			dwMask >>= 1 ;
     	return iShift ;
}

static int MaskToLShift (DWORD dwMask)
{
     	int iShift ;
     	if (dwMask == 0)
          			return 0 ;
     	while (!(dwMask & 1))
          			dwMask >>= 1 ;
     	for (iShift = 0 ; dwMask & 1 ; iShift++)
          			dwMask >>= 1 ;
     	return 8 - iShift ;
}
/*----------------------------------------------------------------------------
	DibCreateFromInfo: All DIB creation functions ultimately call this one.
	This function is responsible for calling CreateDIBSection, allocating
	memory for DIBSTRUCT, and setting up the row pointer.
-----------------------------------------------------------------------------*/

HDIB DibCreateFromInfo (BITMAPINFO * pbmi)
{
     	BYTE      			* 	pBits ;
     	DIBSTRUCT 	* 	pdib ;
     	HBITMAP     			hBitmap ;
     	int         				i, iRowLength, cy, y ;
     
     	hBitmap = CreateDIBSection (NULL, pbmi, DIB_RGB_COLORS, &pBits, NULL, 0) ;
     	if (hBitmap == NULL)
          			return NULL ;
     	if (NULL == (pdib = malloc (sizeof (DIBSTRUCT))))
     	{
          			DeleteObject (hBitmap) ;
          			return NULL ;
 	}

     	pdib->iSignature 	= HDIB_SIGNATURE ;
     	pdib->hBitmap 		= hBitmap ;
     	pdib->pBits      	= pBits ;

     	GetObject (hBitmap, sizeof (DIBSECTION), &pdib->ds) ;
          		// Notice that we can now use the DIB information functions 
          		//   defined above.

          		// If the compression is BI_BITFIELDS, calculate shifts from masks

     	if (DibCompression (pdib) == BI_BITFIELDS)
     	{
          		for (i = 0 ; i < 3 ; i++)
          		{
               			pdib->iLShift[i] = MaskToLShift (pdib->ds.dsBitfields[i]) ;
               			pdib->iRShift[i] = MaskToRShift (pdib->ds.dsBitfields[i]) ;
          		}
     	}

          		// If the compression is BI_RGB, but bit-count is 16 or 32,
          		//   set the bitfields and the masks
     	else if (DibCompression (pdib) == BI_RGB)
     	{
          		if (DibBitCount (pdib) == 16)
          		{
               			pdib->ds.dsBitfields[0] = 0x00007C00 ;
               			pdib->ds.dsBitfields[1] = 0x000003E0 ;
               			pdib->ds.dsBitfields[2] = 0x0000001F ;

               			pdib->iRShift	[0]	= 		10 	;
               			pdib->iRShift	[1]	=  		5 	;
               			pdib->iRShift	[2]	=  		0 	; 

               			pdib->iLShift	[0]	=  		3 	;
               			pdib->iLShift	[1]	=  		3 	;
               			pdib->iLShift	[2]	=  		3 	;
          		}
          		else if (DibBitCount (pdib) == 24 || DibBitCount (pdib) == 32)
          		{
               			pdib->ds.dsBitfields[0] = 0x00FF0000 ;
               			pdib->ds.dsBitfields[1] = 0x0000FF00 ;
               			pdib->ds.dsBitfields[2] = 0x000000FF ;

               			pdib->iRShift	[0] 	= 		16 	;
               			pdib->iRShift	[1] 	=  		8 	;
               			pdib->iRShift	[2] 	=  		0 	; 

               			pdib->iLShift	[0] 	=  		0 	;
               			pdib->iLShift	[1] 	=  		0 	;
               			pdib->iLShift	[2] 	=  		0	;
          		}
	}
          		// Allocate an array of pointers to each row in the DIB
     	cy = DibHeight (pdib) ;
     	if (NULL == (pdib->ppRow = malloc (cy * sizeof (BYTE *))))
     	{
          			free (pdib) ;
          			DeleteObject (hBitmap) ;
          			return NULL ;
     	}

          		// Initialize them.
     	iRowLength = DibRowLength (pdib) ; 
     	if (pbmi->bmiHeader.biHeight > 0)       			// ie, bottom up
     	{
          			for (y = 0 ; y < cy ; y++)
               					pdib->ppRow[y] = pBits + (cy - y - 1) * iRowLength ;
     	}
     	else   														
// top down
     {
          			for (y = 0 ; y < cy ; y++)
               					pdib->ppRow[y] = pBits + y * iRowLength ;
     	}
     	return pdib ;
 }

/*--------------------------------------------------------------------------
   	DibDelete:  Frees all memory for the DIB section
----------------------------------------------------------------------------*/

BOOL DibDelete (HDIB hdib)
{
	DIBSTRUCT * pdib = hdib ;
     	if (!DibIsValid (hdib))
          			return FALSE ;
     	free (pdib->ppRow) ;
     	DeleteObject (pdib->hBitmap) ;
     	free (pdib) ;
     	return TRUE ;
}

/*----------------------------------------------------------------------------
   	DibCreate: Creates an HDIB from explicit arguments
-----------------------------------------------------------------------------*/ 

HDIB DibCreate (int cx, int cy, int cBits, int cColors)
{
     	BITMAPINFO 	* 	pbmi ;
     	DWORD        				dwInfoSize ;
     	HDIB         				hDib ;
     	int          				cEntries ;

     	if (cx <= 0 || cy <= 0 || 
         			((cBits !=  1) && (cBits !=  4) && (cBits !=	8) && 
          				(cBits != 16) && (cBits != 24) && (cBits != 32)))
    	{
          		return NULL ;
  	}

 	if (	cColors != 0)
          			cEntries = cColors ;
  	else	if (cBits <= 8)
          			cEntries = 1 << cBits ;

     	dwInfoSize = sizeof (BITMAPINFOHEADER) + (cEntries - 1) * sizeof (RGBQUAD);

     	if (NULL == (pbmi = malloc (dwInfoSize)))
     	{
          		return NULL ;
     	}

     	ZeroMemory (pbmi, dwInfoSize) ;

     	pbmi->bmiHeader.biSize          		= sizeof (BITMAPINFOHEADER) ;
     	pbmi->bmiHeader.biWidth         		= cx ;
     	pbmi->bmiHeader.biHeight        		= cy ;
     	pbmi->bmiHeader.biPlanes        		= 1 ;
     	pbmi->bmiHeader.biBitCount      		= cBits ;
     	pbmi->bmiHeader.biCompression   		= BI_RGB ;
     	pbmi->bmiHeader.biSizeImage     		= 0 ;
     	pbmi->bmiHeader.biXPelsPerMeter 		= 0 ;
     	pbmi->bmiHeader.biYPelsPerMeter 		= 0 ;
     	pbmi->bmiHeader.biClrUsed       		= cColors ;
     	pbmi->bmiHeader.biClrImportant  		= 0 ;

     	hDib = DibCreateFromInfo (pbmi) ;
     	free (pbmi) ;

     	return hDib ;
}

/*----------------------------------------------------------------------------
	DibCopyToInfo:  		Builds BITMAPINFO structure.
                   							Used by DibCopy and DibCopyToDdb
-----------------------------------------------------------------------------*/

static BITMAPINFO * DibCopyToInfo (HDIB hdib)
{
     	BITMAPINFO 		*	pbmi ;
     	int          					i, iNumColors ;
     	RGBQUAD    			* 	prgb ;
     	if (!DibIsValid (hdib))
          			return NULL ;
          			// Allocate the memory
     	if (NULL == (pbmi = malloc (DibInfoSize (hdib))))
          			return NULL ;
          			// Copy the information header
     	CopyMemory (pbmi, DibInfoHeaderPtr	(hdib), sizeof (BITMAPINFOHEADER));
          
          			// Copy the possible color masks

     	prgb = (RGBQUAD *) ((BYTE *) pbmi + sizeof (BITMAPINFOHEADER)) ;
     	if (DibMaskSize (hdib))
     	{
          			CopyMemory (prgb, DibMaskPtr (hdib), 3 * sizeof (DWORD)) ;
          			prgb = (RGBQUAD *) ((BYTE *) prgb + 3 * sizeof (DWORD)) ;
 	}
          			// Copy the color table
     	iNumColors = DibNumColors (hdib) ;
     	for (i = 0 ; i < iNumColors ; i++)
          			DibGetColor (hdib, i, prgb + i) ;
     	return pbmi ;
}

/*--------------------------------------------------------------------------
   	DibCopy:  Creates a new DIB section from an existing DIB section,
     		possibly swapping the DIB width and height.
---------------------------------------------------------------------------*/

HDIB DibCopy (HDIB hdibSrc, BOOL fRotate)
{
     	BITMAPINFO 		* 	pbmi ;
     	BYTE       		* 	pBitsSrc, * pBitsDst ;
     	HDIB         	hdibDst ;

     	if (!DibIsValid (hdibSrc))
          			return NULL ;
     	if (NULL == (pbmi = DibCopyToInfo (hdibSrc)))
          			return NULL ;
     	if (fRotate)
     	{
          			pbmi->bmiHeader.biWidth = DibHeight (hdibSrc) ;
          			pbmi->bmiHeader.biHeight = DibWidth (hdibSrc) ;
     	}

     	hdibDst = DibCreateFromInfo (pbmi) ;
     	free (pbmi) ;

     	if (	hdibDst == NULL)
          			return NULL ;

          				// Copy the bits

     	if (!fRotate)
     	{
          				pBitsSrc = DibBitsPtr (hdibSrc) ;
          				pBitsDst = DibBitsPtr (hdibDst) ;

          				CopyMemory (pBitsDst, pBitsSrc, DibBitsSize (hdibSrc)) ;
     	}
	return hdibDst ;
}

/*----------------------------------------------------------------------------
   	DibCopyToPackedDib is generally used for saving DIBs and for 
 	transferring DIBs to the clipboard. In the second case, the second 
  	argument should be set to TRUE so that the memory is allocated
  	with the GMEM_SHARE flag.
-----------------------------------------------------------------------------*/

BITMAPINFO * DibCopyToPackedDib (HDIB hdib, BOOL fUseGlobal)
{
     	BITMAPINFO 		* 	pPackedDib ;
     	BYTE       		* 	pBits ;
     	DWORD        		dwDibSize ;
     	HDC          		hdcMem ;
     	HGLOBAL      		hGlobal ;
     	int          		iNumColors ;
     	PDIBSTRUCT   		pdib = hdib ;
     	RGBQUAD    		* 	prgb ;

     	if (!DibIsValid (hdib))
          			return NULL ;
          				// Allocate memory for packed DIB
     	dwDibSize = DibTotalSize (hdib) ;
     	if (fUseGlobal)
     	{
          			hGlobal = GlobalAlloc (GHND | GMEM_SHARE, dwDibSize) ;
          			pPackedDib = GlobalLock (hGlobal) ;
     	}
     	else
   	{
          			pPackedDib = malloc (dwDibSize) ;
     	}

     	if (pPackedDib == NULL) 
          			return NULL ;
          			// Copy the information header
     	CopyMemory (pPackedDib, &pdib->ds.dsBmih, sizeof (BITMAPINFOHEADER)) ;
     	prgb = (RGBQUAD *) ((BYTE *) pPackedDib + sizeof (BITMAPINFOHEADER)) ;
          			// Copy the possible color masks
     	if (pdib->ds.dsBmih.biCompression == BI_BITFIELDS)
     	{
          		CopyMemory (prgb, pdib->ds.dsBitfields, 3 * sizeof (DWORD)) ;
          		prgb = (RGBQUAD *) ((BYTE *) prgb + 3 * sizeof (DWORD)) ;
     	}
          			// Copy the color table
     	if (iNumColors = DibNumColors (hdib))
     	{
          			hdcMem = CreateCompatibleDC (NULL) ;
          			SelectObject (hdcMem, pdib->hBitmap) ;
          			GetDIBColorTable (hdcMem, 0, iNumColors, prgb) ;
          			DeleteDC (hdcMem) ;
     	}

     	pBits = (BYTE *) (prgb + iNumColors) ;
          			// Copy the bits
     	CopyMemory (pBits, pdib->pBits, DibBitsSize (pdib)) ;
          			// If last argument is TRUE, unlock global memory block and 
          			//   cast it to pointer in preparation for return

     	if (fUseGlobal)
     	{
          			GlobalUnlock (hGlobal) ;
          			pPackedDib = (BITMAPINFO *) hGlobal ;     
     	}
	return pPackedDib ;
}

/*--------------------------------------------------------------------------
   DibCopyFromPackedDib is generally used for pasting DIBs from the 
     clipboard.
  ------------------------------------------------------------------------*/

HDIB DibCopyFromPackedDib (BITMAPINFO * pPackedDib)
{
     	BYTE     			* 	pBits ;     
     	DWORD      				dwInfoSize, dwMaskSize, dwColorSize ;
     	int        				iBitCount ;
     	PDIBSTRUCT 		pdib ;

          			// Get the size of the information header and do validity check
     
     	dwInfoSize = pPackedDib->bmiHeader.biSize ;
     	if (	dwInfoSize != sizeof (BITMAPCOREHEADER) &&
         			dwInfoSize != sizeof (BITMAPINFOHEADER) &&
         			dwInfoSize != sizeof (BITMAPV4HEADER) &&
         			dwInfoSize != sizeof (BITMAPV5HEADER))
     	{
          			return NULL ;
     	}
          			// Get the possible size of the color masks

     	if (dwInfoSize == sizeof (BITMAPINFOHEADER) &&
          			pPackedDib->bmiHeader.biCompression == BI_BITFIELDS)
     	{
          			dwMaskSize = 3 * sizeof (DWORD) ;
     	}
     	else
     	{
          			dwMaskSize = 0 ;
     	}
          			// Get the size of the color table
     	if (dwInfoSize == sizeof (BITMAPCOREHEADER))
     	{
          			iBitCount = ((BITMAPCOREHEADER *) pPackedDib)->bcBitCount ;

          			if (iBitCount <= 8)
          			{
               		dwColorSize = (1 << iBitCount) * sizeof (RGBTRIPLE) ;
          			}
          			else
               					dwColorSize = 0 ;
   	}
     	else           				// all non-OS/2 compatible DIBs
     	{
          			if (pPackedDib->bmiHeader.biClrUsed > 0)
          			{
              dwColorSize = pPackedDib->bmiHeader.biClrUsed * sizeof (RGBQUAD);
          			}
          			else if (pPackedDib->bmiHeader.biBitCount <= 8)
          			{
               					dwColorSize = (1 << pPackedDib->bmiHeader.biBitCount) * sizeof (RGBQUAD) ;
          			}
          			else
          			{
               					dwColorSize = 0 ;
          			}
     	}
          			// Finally, get the pointer to the bits in the packed DIB
     	pBits = (BYTE *) pPackedDib + dwInfoSize + dwMaskSize + dwColorSize ;
          			// Create the HDIB from the packed-DIB pointer
     	pdib = DibCreateFromInfo (pPackedDib) ;
          			// Copy the pixel bits
     	CopyMemory (pdib->pBits, pBits, DibBitsSize (pdib)) ;
     	return pdib ;
}

/*----------------------------------------------------------------------------
   	DibFileLoad:  Creates a DIB section from a DIB file
-----------------------------------------------------------------------------*/
HDIB DibFileLoad (const TCHAR * szFileName)
{
     	BITMAPFILEHEADER 		bmfh ;
     	BITMAPINFO     			* 	pbmi ;
     	BOOL             						bSuccess ;
     	DWORD            						dwInfoSize, dwBitsSize, dwBytesRead ;
     	HANDLE           					hFile ;
     	HDIB             						hDib ;

		// Open the file: read access, prohibit write access

     	hFile = CreateFile (szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, 
                            OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL) ;
     	if (hFile == INVALID_HANDLE_VALUE)
          			return NULL ;
          			// Read in the BITMAPFILEHEADER
     	bSuccess = ReadFile (	hFile, &bmfh, sizeof (BITMAPFILEHEADER), 
                          			&dwBytesRead, NULL) ;

     	if (!bSuccess 	|| (dwBytesRead != sizeof (BITMAPFILEHEADER))         
                   						|| (bmfh.bfType != * (WORD *) "BM"))
     	{
          			CloseHandle (hFile) ;
          			return NULL ;
     }
          			// Allocate memory for the information structure & read it in
     	dwInfoSize = bmfh.bfOffBits - sizeof (BITMAPFILEHEADER) ;
     	if (NULL == (pbmi = malloc (dwInfoSize)))
     	{
          			CloseHandle (hFile) ;
          			return NULL ;
     	}

     	bSuccess = ReadFile (hFile, pbmi, dwInfoSize, &dwBytesRead, NULL) ;
     	if (!bSuccess || (dwBytesRead != dwInfoSize))
     {
          		CloseHandle (hFile) ;
          		free (pbmi) ;
          		return NULL ;
     	}
          		// Create the DIB
     	hDib = DibCreateFromInfo (pbmi) ;
     	free (pbmi) ;

     	if (hDib == NULL)
     	{
          		CloseHandle (hFile) ;
          		return NULL ;
     	}
          		// Read in the bits
     	dwBitsSize = bmfh.bfSize - bmfh.bfOffBits ;
     	bSuccess = ReadFile (	hFile, ((PDIBSTRUCT) hDib)->pBits, 
                          		dwBitsSize, &dwBytesRead, NULL) ;
     	CloseHandle (hFile) ;
     	if (!bSuccess || (dwBytesRead != dwBitsSize))
     	{
          		DibDelete (hDib) ;
          		return NULL ;
     	}
     	return hDib ;
}

/*--------------------------------------------------------------------------
   	DibFileSave:  Saves a DIB section to a file
----------------------------------------------------------------------------*/

BOOL DibFileSave (HDIB hdib, const TCHAR * szFileName)
{
     	BITMAPFILEHEADER 		bmfh ;
     	BITMAPINFO     			* 	pbmi ;
     	BOOL             		bSuccess ;
     	DWORD            		dwTotalSize, dwBytesWritten ;
     	HANDLE           		hFile ;

     	hFile = CreateFile (szFileName, GENERIC_WRITE, 0, NULL,
                         		CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL) ;
     	if (hFile == INVALID_HANDLE_VALUE)
          			return FALSE ;
     	dwTotalSize  				= DibTotalSize (hdib) ;
     	bmfh.bfType      			= * (WORD *) "BM" ;
     	bmfh.bfSize      			= sizeof (BITMAPFILEHEADER) + dwTotalSize ;
     	bmfh.bfReserved1 		= 0 ;
     	bmfh.bfReserved2 		= 0 ;
     	bmfh.bfOffBits   		= bmfh.bfSize - DibBitsSize (hdib) ;

          			// Write the BITMAPFILEHEADER

     	bSuccess = WriteFile (	hFile, &bmfh, sizeof (BITMAPFILEHEADER), 
                           		&dwBytesWritten, NULL) ;

     	if (!bSuccess || (dwBytesWritten != sizeof (BITMAPFILEHEADER)))
     	{
          			CloseHandle (hFile) ;
          			DeleteFile (szFileName) ;
          			return FALSE ;
     	}
          			// Get entire DIB in packed-DIB format
     	if (NULL == (pbmi = DibCopyToPackedDib (hdib, FALSE)))
     {
          			CloseHandle (hFile) ;
          			DeleteFile (szFileName) ;
          			return FALSE ;
     	}
          			// Write out the packed DIB
     	bSuccess = WriteFile (hFile, pbmi, dwTotalSize, &dwBytesWritten, NULL) ;
     	CloseHandle (hFile) ;
     	free (pbmi) ;

     	if (!bSuccess || (dwBytesWritten != dwTotalSize))
     	{
          			DeleteFile (szFileName) ;
          			return FALSE ;
     	}
     	return TRUE ;
}

/*---------------------------------------------------------------------------
   	DibCopyToDdb:  For more efficient screen displays
---------------------------------------------------------------------------*/
HBITMAP DibCopyToDdb (HDIB hdib, HWND hwnd, HPALETTE hPalette)
{
     	BITMAPINFO 		* 	pbmi ;
     	HBITMAP      				hBitmap ;
     	HDC          					hdc ;

     	if (!DibIsValid (hdib))
          			return NULL ;
     	if (NULL == (pbmi = DibCopyToInfo (hdib)))
          			return NULL ;
     	hdc = GetDC (hwnd) ;
     	if (hPalette)
     	{
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
     	}
     
     	hBitmap = CreateDIBitmap (hdc, DibInfoHeaderPtr (hdib), CBM_INIT,
									   DibBitsPtr (hdib), pbmi, DIB_RGB_COLORS) ;

     	ReleaseDC (hwnd, hdc) ;
     	free (pbmi) ;

     	return hBitmap ;
}

 ï¿½ï¿½Ê½16-22  DIBHELP.H����
DIBHELP.H
/*--------------------------------------------------------------------------
   	DIBHELP.H header file for DIBHELP.C
----------------------------------------------------------------------------*/

typedef void * HDIB ;
     	// Functions in DIBHELP.C
BOOL DibIsValid (HDIB hdib) ;	
HBITMAP DibBitmapHandle (HDIB hdib) ;
int DibWidth (HDIB hdib) ;
int DibHeight (HDIB hdib) ;
int DibBitCount (HDIB hdib) ;
int DibRowLength (HDIB hdib) ;
int DibNumColors (HDIB hdib) ;
DWORD DibMask (HDIB hdib, int i) ;
int DibRShift (HDIB hdib, int i) ;
int DibLShift (HDIB hdib, int i) ;
int DibCompression (HDIB hdib) ;
BOOL DibIsAddressable (HDIB hdib) ;
DWORD DibInfoHeaderSize (HDIB hdib) ;
DWORD DibMaskSize (HDIB hdib) ;
DWORD DibColorSize (HDIB hdib) ;
DWORD DibInfoSize (HDIB hdib) ;
DWORD DibBitsSize (HDIB hdib) ;
DWORD DibTotalSize (HDIB hdib) ;
BITMAPINFOHEADER * DibInfoHeaderPtr (HDIB hdib) ;
DWORD * DibMaskPtr (HDIB hdib) ;
void * DibBitsPtr (HDIB hdib) ;
BOOL DibGetColor (HDIB hdib, int index, RGBQUAD * prgb) ;
BOOL DibSetColor (HDIB hdib, int index, RGBQUAD * prgb) ;
BYTE * DibPixelPtr (HDIB hdib, int x, int y) ;
DWORD DibGetPixel (HDIB hdib, int x, int y) ;
BOOL DibSetPixel (HDIB hdib, int x, int y, DWORD dwPixel) ;
BOOL DibGetPixelColor (HDIB hdib, int x, int y, RGBQUAD * prgb) ;
BOOL DibSetPixelColor (HDIB hdib, int x, int y, RGBQUAD * prgb) ;
HDIB DibCreateFromInfo (BITMAPINFO * pbmi) ;
BOOL DibDelete (HDIB hdib) ;
HDIB DibCreate (int cx, int cy, int cBits, int cColors) ;
HDIB DibCopy (HDIB hdibSrc, BOOL fRotate) ;
BITMAPINFO * DibCopyToPackedDib (HDIB hdib, BOOL fUseGlobal) ;
HDIB DibCopyFromPackedDib (BITMAPINFO * pPackedDib) ;
HDIB DibFileLoad (const TCHAR * szFileName) ;
BOOL DibFileSave (HDIB hdib, const TCHAR * szFileName) ;
HBITMAP DibCopyToDdb (HDIB hdib, HWND hwnd, HPALETTE hPalette) ;
HDIB DibCreateFromDdb (HBITMAP hBitmap) ;

/*---------------------------------------------------------------------------
   	Quickie no-bounds-checked pixel gets and sets
-----------------------------------------------------------------------------*/

#define 	DibPixelPtr1(hdib, x, y)	(((* (PBYTE **) hdib) [y]) + ((x) >> 3))
#define 	DibPixelPtr4(hdib, x, y)	(((* (PBYTE **) hdib) [y]) + ((x) >> 1))
#define 	DibPixelPtr8(hdib, x, y)	(((* (PBYTE **) hdib) [y]) +  (x)  		)
#define 	DibPixelPtr16(hdib, x, y)  \
                        				 ((WORD *) (((* (PBYTE **) hdib) [y]) +  (x) *  2))

#define DibPixelPtr24(hdib, x, y)  \
                   						((RGBTRIPLE *) (((* (PBYTE **) hdib) [y]) +  (x) *  3))
#define DibPixelPtr32(hdib, x, y)  \
                       						((DWORD *) (((* (PBYTE **) hdib) [y]) +  (x) *  4))

#define DibGetPixel1(hdib, x, y)   \
               				(0x01 & (* DibPixelPtr1 (hdib, x, y) >> (7 - ((x) & 7))))

#define DibGetPixel4(hdib, x, y)   \
               				(0x0F & (* DibPixelPtr4 (hdib, x, y) >> ((x) & 1 ? 0 : 4)))

#define 	DibGetPixel8(hdib, x, y)     			(* DibPixelPtr8  			(hdib, x, y))
#define 	DibGetPixel16(hdib, x, y)  	(* DibPixelPtr16 	(hdib, x, y))
#define 	DibGetPixel24(hdib, x, y)    	(* DibPixelPtr24 	(hdib, x, y))
#define 	DibGetPixel32(hdib, x, y)    	(* DibPixelPtr32	(hdib, x, y))

#define DibSetPixel1(hdib, x, y, p)														\
          		((* DibPixelPtr1 (hdib, x, y) &= ~( 1	<< (7 - ((x) & 7)))), 			\
           		(* DibPixelPtr1 (hdib, x, y) |=	((p) << (7 - ((x) & 7)))))

#define DibSetPixel4(hdib, x, y, p)														\
          		((* DibPixelPtr4 (hdib, x, y) &= (0x0F <<	((x) & 1 ? 4 : 0))),	\
         		(* DibPixelPtr4 (hdib, x, y) |= ((p)	<<	((x) & 1 ? 0 : 4))))

#define DibSetPixel8(hdib, x, y, p)  (* DibPixelPtr8 (hdib, x, y) = p)
#define DibSetPixel16(hdib, x, y, p) (* DibPixelPtr16 (hdib, x, y) = p)
#define DibSetPixel24(hdib, x, y, p) (* DibPixelPtr24 (hdib, x, y) = p)
#define DibSetPixel32(hdib, x, y, p) (* DibPixelPtr32 (hdib, x, y) = p)

 ï¿½ï¿½Ê½16-23  DIBBLE
DIBBLE.C
/*---------------------------------------------------------------------------
   	DIBBLE.C -- 	Bitmap and Palette Program
               						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#include "dibhelp.h"
#include "dibpal.h"
#include "dibconv.h"
#include "resource.h"

#define WM_USER_SETSCROLLS    		(WM_USER + 1)
#define WM_USER_DELETEDIB     		(WM_USER + 2)
#define WM_USER_DELETEPAL     		(WM_USER + 3)
#define WM_USER_CREATEPAL     		(WM_USER + 4)

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("Dibble") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HACCEL   		hAccel ;
     	HWND     		hwnd ;
     	MSG      		msg ;
     	WNDCLASS 		wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName	 	= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     	}

     	hwnd	=	CreateWindow (	szAppName, szAppName,
                WS_OVERLAPPEDWINDOW | WM_VSCROLL | WM_HSCROLL,
                CW_USEDEFAULT, CW_USEDEFAULT,
                CW_USEDEFAULT, CW_USEDEFAULT, 
                NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	hAccel = LoadAccelerators (hInstance, szAppName) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		if (!TranslateAccelerator (hwnd, hAccel, &msg))
          		{
               				TranslateMessage (&msg) ;
               				DispatchMessage (&msg) ;
          		}
     	}
     	return msg.wParam ;
}

/*----------------------------------------------------------------------------
   	DisplayDib: 		Displays or prints DIB actual size or stretched 
               						depending on menu selection
-----------------------------------------------------------------------------*/

int DisplayDib (	HDC hdc, HBITMAP hBitmap, int x, int y, 
                						int cxClient, int cyClient, 
                						WORD wShow, BOOL fHalftonePalette)
{
     	BITMAP 		bitmap ;
     	HDC    			hdcMem ; 
     	int    			cxBitmap, cyBitmap, iReturn ;
     	GetObject	(hBitmap, sizeof (BITMAP), &bitmap) ;
     	cxBitmap 		=	bitmap.bmWidth ;
     	cyBitmap 		=	bitmap.bmHeight ;

     	SaveDC (hdc) ;
     	if (fHalftonePalette)
          			SetStretchBltMode (hdc, HALFTONE) ;
     	else
          			SetStretchBltMode (hdc, COLORONCOLOR) ;
     	hdcMem = CreateCompatibleDC (hdc) ;
     	SelectObject (hdcMem, hBitmap) ;

     	switch (wShow)
     	{
     	case 	IDM_SHOW_NORMAL:
          			if (fHalftonePalette)
   					iReturn = StretchBlt (hdc,	0, 0, min (cxClient, cxBitmap - x), 
					min (cyClient, cyBitmap - y), 
                    hdcMem, x, y, min (cxClient, cxBitmap - x), 
                                  min (cyClient, cyBitmap - y), 
                    SRCCOPY);
          			else
               			iReturn = BitBlt (hdc,0, 0, min (cxClient, cxBitmap - x), 
                        min (cyClient, cyBitmap - y),
hdcMem, x, y, SRCCOPY) ;
          			break ;
               
     	case 	IDM_SHOW_CENTER:
          			if (fHalftonePalette)
               		iReturn = StretchBlt (	hdc, (cxClient - cxBitmap) / 2,
                                         (cyClient - cyBitmap) / 2, 
cxBitmap, cyBitmap,
                              hdcMem, 0, 0, cxBitmap, cyBitmap, SRCCOPY);
          			else
               				iReturn = BitBlt (hdc, 	(cxClient - cxBitmap) / 2,
                            cyClient - cyBitmap) / 2, 
                            cxBitmap, cyBitmap,
                            hdcMem, 0, 0, SRCCOPY) ;
          			break ;
     	case 	IDM_SHOW_STRETCH:
          			iReturn = StretchBlt (hdc,	0, 0, cxClient, cyClient, 
                    hdcMem, 	0, 0, cxBitmap, cyBitmap, SRCCOPY) ;
          			break ;

     	case 	IDM_SHOW_ISOSTRETCH:
         	 		SetMapMode (hdc, MM_ISOTROPIC) ;
          			SetWindowExtEx (hdc, cxBitmap, cyBitmap, NULL) ;
          			SetViewportExtEx (hdc, cxClient, cyClient, NULL) ;
          			SetWindowOrgEx (hdc, cxBitmap / 2, cyBitmap / 2, NULL) ;
          			SetViewportOrgEx (hdc, cxClient / 2, cyClient / 2, NULL) ;

          			iReturn = StretchBlt (hdc,	0, 0, cxBitmap, cyBitmap, 
                    hdcMem,	0, 0, cxBitmap, cyBitmap, SRCCOPY) ;
          			break ;
     	}
	DeleteDC (hdcMem) ;
	RestoreDC (hdc, -1) ;
	return iReturn ;
}

/*---------------------------------------------------------------------------
   	DibFlipHorizontal: Calls non-optimized DibSetPixel and DibGetPixel
----------------------------------------------------------------------------*/

HDIB DibFlipHorizontal (HDIB hdibSrc)
{
     	HDIB hdibDst ;
     	int  cx, cy, x, y ;

     	if (!DibIsAddressable (hdibSrc))
          			return NULL ;
     	if (NULL == (hdibDst = DibCopy (hdibSrc, FALSE)))
          			return NULL ;
     	cx = DibWidth  	(hdibSrc) ;
     	cy = DibHeight 	(hdibSrc) ;
     
	for (x = 0 ; x < cx ; x++)
     	for (y = 0 ; y < cy ; y++)
     	{
          		DibSetPixel (hdibDst, x, cy - 1 - y, DibGetPixel (hdibSrc, x, y)) ;
     	}

     	return hdibDst ;
}

/*---------------------------------------------------------------------------
   	DibRotateRight: Calls optimized DibSetPixelx and DibGetPixelx
-----------------------------------------------------------------------------*/

HDIB DibRotateRight (HDIB hdibSrc)
{
     	HDIB 	hdibDst ;
     	int 	cx, cy, x, y ;

     	if (!DibIsAddressable (hdibSrc))
          			return NULL ;

     	if (NULL == (hdibDst = DibCopy (hdibSrc, TRUE)))
          			return NULL ;

     	cx = DibWidth (hdibSrc) ;
     	cy = DibHeight (hdibSrc) ;

     	switch (DibBitCount (hdibSrc))
     {
     	case  		1:  
          				for (	x = 0 ; x < cx ; x++)
          				for (	y = 0 ; y < cy ; y++)
               							DibSetPixel1 (hdibDst, cy - y - 1, x, 
                    							DibGetPixel1 (hdibSrc, x, y)) ;
          				break ;

     	case  		4:  
          				for (	x = 0 ; x < cx ; x++)
          				for (	y = 0 ; y < cy ; y++)
               							DibSetPixel4 (hdibDst, cy - y - 1, x, 
                    							DibGetPixel4 (hdibSrc, x, y)) ;
          				break ;

     	case  		8:
          				for (	x = 0 ; x < cx ; x++)
          				for (	y = 0 ; y < cy ; y++)
               							DibSetPixel8 (hdibDst, cy - y - 1, x, 
                    							DibGetPixel8 (hdibSrc, x, y)) ;
          				break ;
     	case 		16:  
          				for (x = 0 ; x < cx ; x++)
          				for (y = 0 ; y < cy ; y++)
               						DibSetPixel16 (hdibDst, cy - y - 1, x, 
                    							DibGetPixel16 (hdibSrc, x, y)) ;
          				break ;

     	case 		24:
          				for (x = 0 ; x < cx ; x++)
          				for (y = 0 ; y < cy ; y++)
               						DibSetPixel24 (hdibDst, cy - y - 1, x, 
                    							DibGetPixel24 (hdibSrc, x, y)) ;
          				break ;

     	case 		32:  
          				for (x = 0 ; x < cx ; x++)
          				for (y = 0 ; y < cy ; y++)
               						DibSetPixel32 (hdibDst, cy - y - 1, x, 
                    							DibGetPixel32 (hdibSrc, x, y)) ;
          				break ;
     	}
     	return hdibDst ;
}

/*------------------------------------------------------------------------
   	PaletteMenu: Uncheck and check menu item on palette menu
--------------------------------------------------------------------------*/

void PaletteMenu (HMENU hMenu, WORD wItemNew)
{
     	static WORD wItem = IDM_PAL_NONE ;
     	CheckMenuItem (hMenu, wItem, MF_UNCHECKED) ;
     	wItem = wItemNew ;
     	CheckMenuItem (hMenu, wItem, MF_CHECKED) ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static 	BOOL      				fHalftonePalette ;
     	static 		DOCINFO  			di = {sizeof(DOCINFO),TEXT("Dibble:Printing")} ;
     	static 	HBITMAP			hBitmap ;
     	static 	HDIB        				hdib ;
     	static 	HMENU        				hMenu ;
     	static 	HPALETTE			hPalette ;
     	static 	int          				cxClient, cyClient, iVscroll, iHscroll ;
     	static 	OPENFILENAME 	ofn ;
     	static 	PRINTDLG     			printdlg = { sizeof (PRINTDLG) } ;
     	static 	TCHAR        				szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static 	TCHAR        				szFilter[]=	TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
               TEXT ("All Files (*.*)\0*.*\0\0") ;
     	static TCHAR      		* 		szCompression[] = { 
                          TEXT("BI_RGB"),TEXT("BI_RLE8"),TEXT("BI_RLE4"), 
        TEXT("BI_BITFIELDS"),TEXT("Unknown")} ;
     	static WORD         	wShow = IDM_SHOW_NORMAL ;
     	BOOL                	fSuccess ;
     	BYTE              		*		pGlobal ;
     	HDC                 	hdc, hdcPrn ;
     	HGLOBAL             	hGlobal ;
     	HDIB                	hdibNew ;
     	int                 	iEnable, cxPage, cyPage, iConvert ;
     	PAINTSTRUCT         	ps ;
     	SCROLLINFO          	si ;
     	TCHAR               	szBuffer [256] ;

     	switch (message)
     	{
     	case 	WM_CREATE:
         
               				// Save the menu handle in a static variable

          			hMenu = GetMenu (hwnd) ;

               		// Initialize the OPENFILENAME structure for the File Open
               		//   and File Save dialog boxes.

          			ofn.lStructSize       	= sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         	= hwnd ;
          			ofn.hInstance         	= NULL ;
          			ofn.lpstrFilter       	= szFilter ;
          			ofn.lpstrCustomFilter 	= NULL ;
          			ofn.nMaxCustFilter    	= 0 ;
          			ofn.nFilterIndex      	= 0 ;
          			ofn.lpstrFile         	= szFileName ;
          			ofn.nMaxFile          	= MAX_PATH ;
          			ofn.lpstrFileTitle    	= szTitleName ;
          			ofn.nMaxFileTitle     	= MAX_PATH ;
          			ofn.lpstrInitialDir   	= NULL ;
          			ofn.lpstrTitle        	= NULL ;
          			ofn.Flags             	= OFN_OVERWRITEPROMPT ;
          			ofn.nFileOffset       	= 0 ;
          			ofn.nFileExtension    	= 0 ;
          			ofn.lpstrDefExt       	= TEXT ("bmp") ;
          			ofn.lCustData         	= 0 ;
          			ofn.lpfnHook          	= NULL ;
          			ofn.lpTemplateName    	= NULL ;
          			return 0 ;

     	case 	WM_DISPLAYCHANGE:
          			SendMessage (hwnd, WM_USER_DELETEPAL, 0, 0) ;
          			SendMessage (hwnd, WM_USER_CREATEPAL, TRUE, 0) ;
          			return 0 ;

     	case 	WM_SIZE:
               			// Save the client area width and height in static variables.

          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;

          			wParam = FALSE ;
                        // fall through
               			// WM_USER_SETSCROLLS:  Programmer-defined Message!
               			// Set the scroll bars. If the display mode is not normal,
               			//   make them invisible. If wParam is TRUE, reset the 
               			//   scroll bar position.

     	case 	WM_USER_SETSCROLLS:
          			if (hdib == NULL || wShow != IDM_SHOW_NORMAL)
          			{
               					si.cbSize 		= sizeof (SCROLLINFO) ;
               					si.fMask  		= SIF_RANGE ;
               					si.nMin   		= 0 ;
               					si.nMax   		= 0 ;
               					SetScrollInfo (hwnd, SB_VERT, &si, TRUE) ;
               					SetScrollInfo (hwnd, SB_HORZ, &si, TRUE) ;
          			}
          			else
          			{
                    					// First the vertical scroll

               					si.cbSize 		= sizeof (SCROLLINFO) ;
               					si.fMask  			= SIF_ALL ;

               				GetScrollInfo (hwnd, SB_VERT, &si) ;
               					si.nMin  			= 0 ;
               					si.nMax  			= DibHeight (hdib) ;
               					si.nPage 			= cyClient ;
               					if ((BOOL) wParam)
                    							si.nPos = 0 ;

               					SetScrollInfo (hwnd, SB_VERT, &si, TRUE) ;
               					GetScrollInfo (hwnd, SB_VERT, &si) ;

               					iVscroll = si.nPos ;

                    						// Then the horizontal scroll

               					GetScrollInfo (hwnd, SB_HORZ, &si) ;
               					si.nMin  		= 0 ;
               					si.nMax  		= DibWidth (hdib) ;
               					si.nPage 		= cxClient ;
          
               					if ((BOOL) wParam)
                    							si.nPos = 0 ;

               					SetScrollInfo (hwnd, SB_HORZ, &si, TRUE) ;
               					GetScrollInfo (hwnd, SB_HORZ, &si) ;

               					iHscroll = si.nPos ;
          			}	
          			return 0 ;

          			// WM_VSCROLL: Vertically scroll the DIB

     	case 	WM_VSCROLL:
          			si.cbSize = sizeof (SCROLLINFO) ;
          			si.fMask  = SIF_ALL ;
          			GetScrollInfo (hwnd, SB_VERT, &si) ;
          
          			iVscroll = si.nPos ;

          			switch (LOWORD (wParam))
          			{
          			case SB_LINEUP:    si.nPos -	= 1 ; 		break ;
          			case SB_LINEDOWN:  si.nPos +	= 1 ;		break ;
          			case SB_PAGEUP:    si.nPos -	= si.nPage ;break ;
          			case SB_PAGEDOWN:  si.nPos +	= si.nPage ;break ;
          			case SB_THUMBTRACK:si.nPos		= si.nTrackPos ;break ;
          			default:   										break ;
          			}
          			si.fMask = SIF_POS ;
          			SetScrollInfo (hwnd, SB_VERT, &si, TRUE) ;
          			GetScrollInfo (hwnd, SB_VERT, &si) ;
          			if (si.nPos != iVscroll)
          			{
               				ScrollWindow (hwnd, 0, iVscroll - si.nPos, NULL, NULL) ;
               				iVscroll = si.nPos ;
               				UpdateWindow (hwnd) ;
          			}
          			return 0 ;

          			// WM_HSCROLL: Horizontally scroll the DIB

     	case 	WM_HSCROLL:
          			si.cbSize = sizeof (SCROLLINFO) ;
          			si.fMask  = SIF_ALL ;
          			GetScrollInfo (hwnd, SB_HORZ, &si) ;
          
          			iHscroll = si.nPos ;

          			switch (LOWORD (wParam))
          			{
          			case SB_LINELEFT:  si.nPos -=1 ;	break ;
          			case SB_LINERIGHT: si.nPos +=1 ;	break ;
          			case SB_PAGELEFT:  si.nPos -=si.nPage ;break ;
          			case SB_PAGERIGHT: si.nPos +=si.nPage ;break ;
          			case SB_THUMBTRACK:si.nPos  =si.nTrackPos ;break ;
          			default:  								   break ;
          			}

          			si.fMask = SIF_POS ;
          			SetScrollInfo (hwnd, SB_HORZ, &si, TRUE) ;
          			GetScrollInfo (hwnd, SB_HORZ, &si) ;

          			if (si.nPos != iHscroll)
          			{
               				ScrollWindow (hwnd, iHscroll - si.nPos, 0, NULL, NULL) ;
               				iHscroll = si.nPos ;
               				UpdateWindow (hwnd) ;
          			}
          			return 0 ;

          			// WM_INITMENUPOPUP:  Enable or Gray menu items

	case 	WM_INITMENUPOPUP:
          			if (hdib)
               					iEnable = MF_ENABLED ;
          			else
               					iEnable = MF_GRAYED ;
       EnableMenuItem (hMenu, IDM_FILE_SAVE,       		iEnable) ;
       EnableMenuItem (hMenu, IDM_FILE_PRINT,      		iEnable) ;
       EnableMenuItem (hMenu, IDM_FILE_PROPERTIES, 		iEnable) ;
       EnableMenuItem (hMenu, IDM_EDIT_CUT,        		iEnable) ;
       EnableMenuItem (hMenu, IDM_EDIT_COPY,       		iEnable) ;
       EnableMenuItem (hMenu, IDM_EDIT_DELETE,     		iEnable) ;

          			if (DibIsAddressable (hdib))
               					iEnable = MF_ENABLED ;
          			else
               					iEnable = MF_GRAYED ;

          EnableMenuItem (hMenu, IDM_EDIT_ROTATE,    	iEnable) ;
          EnableMenuItem (hMenu, IDM_EDIT_FLIP,      	iEnable) ;
          EnableMenuItem (hMenu, IDM_CONVERT_01,     	iEnable) ;
          EnableMenuItem (hMenu, IDM_CONVERT_04,     	iEnable) ;
          EnableMenuItem (hMenu, IDM_CONVERT_08,     	iEnable) ;
          EnableMenuItem (hMenu, IDM_CONVERT_16,     	iEnable) ;
          EnableMenuItem (hMenu, IDM_CONVERT_24,     	iEnable) ;
          EnableMenuItem (hMenu, IDM_CONVERT_32,     	iEnable) ;

          			switch (DibBitCount (hdib))
          			{
          			case  	1: 	EnableMenuItem (hMenu, IDM_CONVERT_01, MF_GRAYED) ; 	break ;
          			case  	4: 	EnableMenuItem (hMenu, IDM_CONVERT_04, MF_GRAYED) ; 	break ;
          			case  	8: 	EnableMenuItem (hMenu, IDM_CONVERT_08, MF_GRAYED) ; 	break ;
          			case 	16: EnableMenuItem (hMenu, IDM_CONVERT_16, MF_GRAYED) ; 	break ;
          			case 	24: EnableMenuItem (hMenu, IDM_CONVERT_24, MF_GRAYED) ; 	break ;
          			case 	32: EnableMenuItem (hMenu, IDM_CONVERT_32, MF_GRAYED) ; 	break ;
          			}

          			if (hdib && DibColorSize (hdib) > 0)
               					iEnable = MF_ENABLED ;
          			else
               					iEnable = MF_GRAYED ;

          			EnableMenuItem (hMenu, IDM_PAL_DIBTABLE,    iEnable) ;
          		if (DibIsAddressable (hdib) && DibBitCount (hdib) > 8)
               					iEnable = MF_ENABLED ;
          			else
               					iEnable = MF_GRAYED ;

          	EnableMenuItem 		(hMenu, IDM_PAL_OPT_POP4,   		iEnable) ;
          	EnableMenuItem 		(hMenu, IDM_PAL_OPT_POP5,   		iEnable) ;
          	EnableMenuItem 		(hMenu, IDM_PAL_OPT_POP6,   		iEnable) ;
          	EnableMenuItem 		(hMenu, IDM_PAL_OPT_MEDCUT, 		iEnable) ;
          	EnableMenuItem 		(hMenu, IDM_EDIT_PASTE, 
               	IsClipboardFormatAvailable (CF_DIB) ? MF_ENABLED : MF_GRAYED) ;

          			return 0 ;

          			// WM_COMMAND:  Process all menu commands.

     	case 	WM_COMMAND:
          			iConvert = 0 ;

          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_OPEN:

                   // Show the File Open dialog box

               					if (!GetOpenFileName (&ofn))
                    							return 0 ;
               
                   // If there's an existing DIB and palette, delete them

               					SendMessage (hwnd, WM_USER_DELETEDIB, 0, 0) ;
               
                   // Load the DIB into memory

               					SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               					ShowCursor (TRUE) ;

               					hdib = DibFileLoad (szFileName) ;

               					ShowCursor (FALSE) ;
               					SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

                    							// Reset the scroll bars

               					SendMessage (hwnd, WM_USER_SETSCROLLS, TRUE, 0) ;

                    							// Create the palette and DDB

               					SendMessage (hwnd, WM_USER_CREATEPAL, TRUE, 0) ;

               					if (!hdib)
               					{
                  MessageBox (hwnd, TEXT ("Cannot load DIB file!"), 
                              szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               					}
               					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;

   		case	IDM_FILE_SAVE:

                    			// Show the File Save dialog box

               					if 	(!	GetSaveFileName (&ofn))
                    							return 0 ;

                    			// Save the DIB to memory

               					SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               					ShowCursor (TRUE) ;

               					fSuccess = DibFileSave (hdib, szFileName) ;

               					ShowCursor (FALSE) ;
               					SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               					if (!fSuccess)
                   MessageBox (	hwnd, TEXT ("Cannot save DIB file!"),
                                szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               					return 0 ;

          			case 	IDM_FILE_PRINT:
               					if (!hdib)
                    							return 0 ;

                    							// Get printer DC

               		printdlg.Flags = PD_RETURNDC | PD_NOPAGENUMS | PD_NOSELECTION ;

               					if (!PrintDlg (&printdlg))
                    							return 0 ;

               					if (NULL == (hdcPrn = printdlg.hDC))
               					{
                    MessageBox(	hwnd, TEXT ("Cannot obtain Printer DC"),
                                szAppName, MB_ICONEXCLAMATION | MB_OK) ;
                    							return 0 ;
               					}
                    		// Check if the printer can print bitmaps

          if (!(RC_BITBLT & GetDeviceCaps (hdcPrn, RASTERCAPS)))
               					{
                    						DeleteDC (hdcPrn) ;
          MessageBox (	hwnd, TEXT ("Printer cannot print bitmaps"),
                        szAppName, MB_ICONEXCLAMATION | MB_OK) ;
                    						return 0 ;
               					}
                    						// Get size of printable area of page

               					cxPage = GetDeviceCaps (hdcPrn, HORZRES) ;
               					cyPage = GetDeviceCaps (hdcPrn, VERTRES) ;

               					fSuccess = FALSE ;

                    						// Send the DIB to the printer

               				SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               				ShowCursor (TRUE) ;

               				if ((StartDoc (hdcPrn, &di) > 0) && (StartPage (hdcPrn) > 0))
            				{
                    		DisplayDib (hdcPrn, DibBitmapHandle (hdib), 0, 0, 
                                        cxPage, cyPage, wShow, FALSE) ;
                    
                    						if (EndPage (hdcPrn) > 0)
                    						{
                         								fSuccess = TRUE ;
                         								EndDoc (hdcPrn) ;
                    						}
               				}
               				ShowCursor (FALSE) ;
               				SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               				DeleteDC (hdcPrn) ;

               				if (	!fSuccess)
                   MessageBox (	hwnd, TEXT ("Could not print bitmap"),
                                szAppName, MB_ICONEXCLAMATION | MB_OK) ;
               				return 0 ;

          		case	IDM_FILE_PROPERTIES:
               				if (!hdib)
                    						return 0 ;

				wsprintf (szBuffer, TEXT ("Pixel width:\t%i\n")
                                    TEXT ("Pixel height:\t%i\n")
                                   	TEXT ("Bits per pixel:\t%i\n")
                                   	TEXT ("Number of colors:\t%i\n")
                                   	TEXT ("Compression:\t%s\n"),
                        DibWidth (hdib), DibHeight (hdib),
                        DibBitCount (hdib), DibNumColors (hdib),
                        szCompression [min (3, DibCompression (hdib))]) ;

               			MessageBox (	hwnd, szBuffer, szAppName, 
                        MB_ICONEXCLAMATION | MB_OK) ;
               				return 0 ;

          		case 	IDM_APP_EXIT:
               				SendMessage (hwnd, WM_CLOSE, 0, 0) ;
               				return 0 ;

          		case 	IDM_EDIT_COPY:
          		case 	IDM_EDIT_CUT:
               				if (!(hGlobal = DibCopyToPackedDib (hdib, TRUE)))
                    						return 0 ;

               				OpenClipboard (hwnd) ;
               				EmptyClipboard () ;
               				SetClipboardData (CF_DIB, hGlobal) ;
               				CloseClipboard () ;

               				if (LOWORD (wParam) == IDM_EDIT_COPY)
                    		return 0 ;
                            // fall through for IDM_EDIT_CUT
          		case 	IDM_EDIT_DELETE:
               				SendMessage (hwnd, WM_USER_DELETEDIB, 0, 0) ;
               				InvalidateRect (hwnd, NULL, TRUE) ;
               				return 0 ;

          		case 	IDM_EDIT_PASTE:
               				OpenClipboard (hwnd) ;

               				hGlobal = GetClipboardData (CF_DIB) ;
               				pGlobal = GlobalLock (hGlobal) ;

                    		// If there's an existing DIB and palette,delete them.
                    		// Then convert the packed DIB to an HDIB.

               				if (pGlobal)
               				{
                    		SendMessage (hwnd, WM_USER_DELETEDIB, 0, 0) ;
                    		hdib = DibCopyFromPackedDib ((BITMAPINFO *) pGlobal) ;
                    		SendMessage (hwnd, WM_USER_CREATEPAL, TRUE, 0) ;
               				}

               				GlobalUnlock (hGlobal) ;
               				CloseClipboard () ;
                    					// Reset the scroll bars

               				SendMessage (hwnd, WM_USER_SETSCROLLS, TRUE, 0) ;
               				InvalidateRect (hwnd, NULL, TRUE) ;
               				return 0 ;

          		case 	IDM_EDIT_ROTATE:
               				if (hdibNew = DibRotateRight (hdib))
               				{
                    			DibDelete (hdib) ;
                    			DeleteObject (hBitmap) ;
                    			hdib = hdibNew ;
                    			hBitmap = DibCopyToDdb (hdib, hwnd, hPalette) ;
                    			SendMessage (hwnd, WM_USER_SETSCROLLS, TRUE, 0) ;
                    			InvalidateRect (hwnd, NULL, TRUE) ;
               				}
               				else
               				{
                    MessageBox (	hwnd, TEXT ("Not enough memory"),
                                	szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               				}
               				return 0 ;

          		case 	IDM_EDIT_FLIP:
               				if (hdibNew = DibFlipHorizontal (hdib))
               				{
                    			DibDelete (hdib) ;
                    			DeleteObject (hBitmap) ;
                    			hdib = hdibNew ;
                    			hBitmap = DibCopyToDdb (hdib, hwnd, hPalette) ;
                    			InvalidateRect (hwnd, NULL, TRUE) ;
               				}
               				else
               				{
                    MessageBox (	hwnd, TEXT ("Not enough memory"),
                                	szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               				}
               				return 0 ;

          		case 	IDM_SHOW_NORMAL:
          		case 	IDM_SHOW_CENTER:
          		case 	IDM_SHOW_STRETCH:
          		case 	IDM_SHOW_ISOSTRETCH:
               				CheckMenuItem (hMenu, wShow, MF_UNCHECKED) ;
               				wShow = LOWORD (wParam) ;
               				CheckMenuItem (hMenu, wShow, MF_CHECKED) ;
               				SendMessage (hwnd, WM_USER_SETSCROLLS, FALSE, 0) ;

               				InvalidateRect (hwnd, NULL, TRUE) ;
               				return 0 ;

          		case 	IDM_CONVERT_32:  iConvert += 8 ;
          		case 	IDM_CONVERT_24:  iConvert += 8 ;   
          		case 	IDM_CONVERT_16:  iConvert += 8 ;
          		case 	IDM_CONVERT_08:  iConvert += 4 ;
          		case	IDM_CONVERT_04:  iConvert += 3 ;
          		case 	IDM_CONVERT_01:  iConvert += 1 ;
               				SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               				ShowCursor (TRUE) ;

               				hdibNew = DibConvert (hdib, iConvert) ;

               				ShowCursor (FALSE) ;
               				SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               				if (hdibNew)
               				{
                    	SendMessage (hwnd, WM_USER_DELETEDIB, 0, 0) ;
                    				hdib = hdibNew ;
                    	SendMessage (hwnd, WM_USER_CREATEPAL, TRUE, 0) ;
                    	InvalidateRect (hwnd, NULL, TRUE) ;
               				}
               				else
               				{
                     MessageBox (	hwnd, TEXT ("Not enough memory"),
                                	szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               					}
               					return 0 ;

          			case 	IDM_APP_ABOUT:
           MessageBox (	hwnd, TEXT ("Dibble (c) Charles Petzold, 1998"),
                        szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               			return 0 ;
          			}
     
               			// All the other WM_COMMAND messages are from the palette
               			//	 items. Any existing palette is deleted, and the cursor
               			//	 is set to the hourglass.

          			SendMessage (hwnd, WM_USER_DELETEPAL, 0, 0) ;
          			SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
          			ShowCursor (TRUE) ;
               			// Notice that all messages for palette items are ended
               			//	 with break rather than return. This is to allow 
               			//	 additional processing later on.

          			switch (LOWORD (wParam))
          			{
          			case 	IDM_PAL_DIBTABLE: 
               					hPalette = DibPalDibTable (hdib) ; 
               					break ;

          			case 	IDM_PAL_HALFTONE: 
               					hdc = GetDC (hwnd) ;

               					if (hPalette = CreateHalftonePalette (hdc))
                    							fHalftonePalette = TRUE ;

               					ReleaseDC (hwnd, hdc) ;
               					break ;

          			case 	IDM_PAL_ALLPURPOSE: 
               					hPalette = DibPalAllPurpose () ; 
               					break ;

       case IDM_PAL_GRAY2:hPalette	    = DibPalUniformGrays   (2)	;	break;
       case IDM_PAL_GRAY3:hPalette 	    = DibPalUniformGrays   (3)	;  	break;
       case IDM_PAL_GRAY4:hPalette 	    = DibPalUniformGrays   (4)	; 	break;
       case IDM_PAL_GRAY8:hPalette 	    = DibPalUniformGrays   (8)	; 	break;
       case	IDM_PAL_GRAY16:hPalette 	= DibPalUniformGrays  (16)	; 	break;
       case IDM_PAL_GRAY32:hPalette 	= DibPalUniformGrays  (32)	; 	break;
       case IDM_PAL_GRAY64:hPalette 	= DibPalUniformGrays  (64)	; 	break;
       case IDM_PAL_GRAY128:hPalette 	= DibPalUniformGrays (128)	; 	break;
       case IDM_PAL_GRAY256:hPalette 	= DibPalUniformGrays (256)	;	break;
       case IDM_PAL_RGB222:hPalette 	= DibPalUniformColors (2,2,2); 	break;
       case IDM_PAL_RGB333:hPalette 	= DibPalUniformColors (3,3,3); 	break;
       case IDM_PAL_RGB444:hPalette 	= DibPalUniformColors (4,4,4); 	break;
       case IDM_PAL_RGB555:hPalette 	= DibPalUniformColors (5,5,5); 	break;
       case IDM_PAL_RGB666:hPalette 	= DibPalUniformColors (6,6,6); 	break;
       case IDM_PAL_RGB775:hPalette 	= DibPalUniformColors (7,7,5); 	break;
       case IDM_PAL_RGB757:hPalette 	= DibPalUniformColors (7,5,7); 	break;
       case IDM_PAL_RGB577:hPalette 	= DibPalUniformColors (5,7,7); 	break;
       case IDM_PAL_RGB884:hPalette 	= DibPalUniformColors (8,8,4); 	break;
       case IDM_PAL_RGB848:hPalette 	= DibPalUniformColors (8,4,8); 	break;
       case IDM_PAL_RGB488:hPalette 	= DibPalUniformColors (4,8,8); 	break;
       case IDM_PAL_OPT_POP4:hPalette   = DibPalPopularity (hdib, 4) ;  break ;
       case IDM_PAL_OPT_POP5:hPalette   = DibPalPopularity (hdib, 5) ;  break ;
       case IDM_PAL_OPT_POP6:hPalette   = DibPalPopularity (hdib, 6) ;  break ;                   
       case IDM_PAL_OPT_MEDCUT:hPalette = DibPalMedianCut  (hdib, 6) ;  break ;
          			}

               		// After processing Palette items from the menu, the cursor
               		// 	is restored to an arrow, the menu item is checked, and
               		//	the window is invalidated.

          			hBitmap = DibCopyToDdb (hdib, hwnd, hPalette) ;

          			ShowCursor (FALSE) ;
          			SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

          			if (hPalette)
               					PaletteMenu (hMenu, (LOWORD (wParam))) ;

          			InvalidateRect (hwnd, NULL, TRUE) ;
          			return 0 ;

          			// This programmer-defined message deletes an existing DIB 
          			//   in preparation for getting a new one.  Invoked during 
          			//   File Open command, Edit Paste command, and others.

 	case	WM_USER_DELETEDIB:
          			if (hdib)
          			{
               					DibDelete (hdib) ;
               					hdib = NULL ;
          			}
          			SendMessage (hwnd, WM_USER_DELETEPAL, 0, 0) ;
          			return 0 ;

          			// This programmer-defined message deletes an existing palette
          			//		in preparation for defining a new one.

     	case 	WM_USER_DELETEPAL:
          			if (hPalette)
          			{
               					DeleteObject (hPalette) ;
               					hPalette = NULL ;
               					fHalftonePalette = FALSE ;
               					PaletteMenu (hMenu, IDM_PAL_NONE) ;
          			}
          			if (hBitmap)
               					DeleteObject (hBitmap) ;

          				return 0 ;

          			// Programmer-defined message to create a new palette based on 
          			//		a new DIB.  If wParam == TRUE, create a DDB as well.

     	case 	WM_USER_CREATEPAL:
          			if (hdib)
          			{
               					hdc = GetDC (hwnd) ;

               		if (!(RC_PALETTE & GetDeviceCaps (hdc, RASTERCAPS)))
               					{
                    PaletteMenu (hMenu, IDM_PAL_NONE) ;
               					}
               					else if (hPalette = DibPalDibTable (hdib))
        					{
                    PaletteMenu (hMenu, IDM_PAL_DIBTABLE) ;
               					}
               					else if (hPalette = CreateHalftonePalette (hdc))
               					{
                    							fHalftonePalette = TRUE ;
                    PaletteMenu (hMenu, IDM_PAL_HALFTONE) ;
               					}
               					ReleaseDC (hwnd, hdc) ;

               					if ((BOOL) wParam)
                    hBitmap = DibCopyToDdb (hdib, hwnd, hPalette) ;
          			}
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (hPalette)
          			{
               					SelectPalette (hdc, hPalette, FALSE) ;
               					RealizePalette (hdc) ;
          			}
          			if (hBitmap)
  			{
               				DisplayDib (	hdc, 
                           	fHalftonePalette ? DibBitmapHandle (hdib) : hBitmap, 
                           	iHscroll, iVscroll, 
                           	cxClient, cyClient,
                           	wShow, fHalftonePalette) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hPalette)
               					return FALSE ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;

          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if (!hPalette || (HWND) wParam == hwnd)
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;

          			ReleaseDC (hwnd, hdc) ;
          			break ;

     	case 	WM_DESTROY:
          			if (hdib)
               					DibDelete (hdib) ;

          			if (hBitmap)
               					DeleteObject (hBitmap) ;

          			if (hPalette)
               					DeleteObject (hPalette) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 DIBBLE.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
// Menu
DIBBLE MENU DISCARDABLE BEGIN POPUP "&File"
    	BEGIN
		MENUITEM "&Open...\tCtrl+O",        IDM_FILE_OPEN
		MENUITEM "&Save...\tCtrl+S",        IDM_FILE_SAVE
 		MENUITEM SEPARATOR
		MENUITEM "&Print...\tCtrl+P",       IDM_FILE_PRINT
		MENUITEM SEPARATOR
		MENUITEM "Propert&ies...",          IDM_FILE_PROPERTIES
		MENUITEM SEPARATOR
		MENUITEM "E&xit",    				  IDM_APP_EXIT
	END
    	POPUP "&Edit"
    	BEGIN	
		MENUITEM "Cu&t\tCtrl+X",  	  IDM_EDIT_CUT
		MENUITEM "&Copy\tCtrl+C",       IDM_EDIT_COPY
    	MENUITEM "&Paste\tCtrl+V", 	  IDM_EDIT_PASTE
   		MENUITEM "&Delete\tDelete", 	  IDM_EDIT_DELETE
       	MENUITEM SEPARATOR		
        MENUITEM "&Flip",    			  IDM_EDIT_FLIP
      	MENUITEM "&Rotate",   		  IDM_EDIT_ROTATE
    	END
    	POPUP "&Show"
    	BEGIN
        MENUITEM "&Actual Size", 	IDM_SHOW_NORMAL, CHECKED
        MENUITEM "&Center",   	IDM_SHOW_CENTER
        MENUITEM "&Stretch to Window",  		IDM_SHOW_STRETCH
        MENUITEM "Stretch &Isotropically",	IDM_SHOW_ISOSTRETCH
    	END
    	POPUP "&Palette"
    	BEGIN
        MENUITEM "&None",				IDM_PAL_NONE, CHECKED
        MENUITEM "&Dib ColorTable", 	IDM_PAL_DIBTABLE
        MENUITEM "&Halftone",     	IDM_PAL_HALFTONE
        MENUITEM "&All-Purpose",    	IDM_PAL_ALLPURPOSE
      	POPUP "&Gray Shades"
        	BEGIN
        MENUITEM "&1. 2 Grays",  		IDM_PAL_GRAY2
        MENUITEM "&2. 3 Grays",       IDM_PAL_GRAY3
        MENUITEM "&3. 4 Grays",       IDM_PAL_GRAY4
        MENUITEM "&4. 8 Grays",       IDM_PAL_GRAY8
        MENUITEM "&5. 16 Grays",      IDM_PAL_GRAY16
        MENUITEM "&6. 32 Grays",      IDM_PAL_GRAY32
        MENUITEM "&7. 64 Grays",	    IDM_PAL_GRAY64
        MENUITEM "&8. 128 Grays",	    IDM_PAL_GRAY128
        MENUITEM "&9. 256 Grays",	    IDM_PAL_GRAY256
        	END
        	POPUP "&Uniform Colors"
     	BEGIN
        MENUITEM "&1. 2R x 2G x 2B (8)",			IDM_PAL_RGB222
        MENUITEM "&2. 3R x 3G x 3B (27)", 		IDM_PAL_RGB333
        MENUITEM "&3. 4R x 4G x 4B (64)",		    IDM_PAL_RGB444
        MENUITEM "&4. 5R x 5G x 5B (125)",      	IDM_PAL_RGB555
        MENUITEM "&5. 6R x 6G x 6B (216)",      	IDM_PAL_RGB666
        MENUITEM "&6. 7R x 7G x 5B (245)",      	IDM_PAL_RGB775
	    MENUITEM "&7. 7R x 5B x 7B (245)",      	IDM_PAL_RGB757
        MENUITEM "&8. 5R x 7G x 7B (245)",      	IDM_PAL_RGB577
        MENUITEM "&9. 8R x 8G x 4B (256)",      	IDM_PAL_RGB884
        MENUITEM "&A. 8R x 4G x 8B (256)",      	IDM_PAL_RGB848
      	MENUITEM "&B. 4R x 8G x 8B (256)",        IDM_PAL_RGB488
        	END
        	POPUP "&Optimized"
        	BEGIN
        MENUITEM "&1. Popularity Algorithm (4 bits)"IDM_PAL_OPT_POP4
        MENUITEM "&2. Popularity Algorithm (5 bits)"IDM_PAL_OPT_POP5
        MENUITEM "&3. Popularity Algorithm (6 bits)"IDM_PAL_OPT_POP6
        MENUITEM "&4. Median Cut Algorithm ", IDM_PAL_OPT_MEDCUT
        	END
    	END
    	POPUP "Con&vert"
    	BEGIN
        MENUITEM "&1. to 1 bit per pixel",      	IDM_CONVERT_01
        MENUITEM "&2. to 4 bits per pixel",     	IDM_CONVERT_04
        MENUITEM "&3. to 8 bits per pixel",     	IDM_CONVERT_08
        MENUITEM "&4. to 16 bits per pixel",    	IDM_CONVERT_16
        MENUITEM "&5. to 24 bits per pixel",    	IDM_CONVERT_24
        MENUITEM "&6. to 32 bits per pixel",    	IDM_CONVERT_32
    	END
    	POPUP "&Help"
    	BEGIN
     		MENUITEM "&About", 
			IDM_APP_ABOUT
    	END
END
/////////////////////////////////////////////////////////////////////////////
// Accelerator
DIBBLE ACCELERATORS DISCARDABLE 
BEGIN
 	"C",          IDM_EDIT_COPY,          VIRTKEY, CONTROL, NOINVERT
    	"O",      IDM_FILE_OPEN,          VIRTKEY, CONTROL, NOINVERT
    	"P",      IDM_FILE_PRINT,         VIRTKEY, CONTROL, NOINVERT
    	"S",      IDM_FILE_SAVE,          VIRTKEY, CONTROL, NOINVERT
    	"V",      IDM_EDIT_PASTE,         VIRTKEY, CONTROL, NOINVERT
    	VK_DELETE,      	IDM_EDIT_DELETE,        VIRTKEY, NOINVERT
    	"X",      IDM_EDIT_CUT,           VIRTKEY, CONTROL, NOINVERT
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by Dibble.rc

#define IDM_FILE_OPEN                40001
#define IDM_FILE_SAVE                40002
#define IDM_FILE_PRINT               40003
#define IDM_FILE_PROPERTIES          40004
#define IDM_APP_EXIT                 40005
#define IDM_EDIT_CUT                 40006
#define IDM_EDIT_COPY                40007
#define IDM_EDIT_PASTE               40008
#define IDM_EDIT_DELETE              40009
#define IDM_EDIT_FLIP                40010
#define IDM_EDIT_ROTATE              40011
#define IDM_SHOW_NORMAL              40012
#define IDM_SHOW_CENTER              40013
#define IDM_SHOW_STRETCH             40014
#define IDM_SHOW_ISOSTRETCH          40015
#define IDM_PAL_NONE                 40016
#define IDM_PAL_DIBTABLE             40017
#define IDM_PAL_HALFTONE             40018
#define IDM_PAL_ALLPURPOSE           40019
#define IDM_PAL_GRAY2                40020
#define IDM_PAL_GRAY3                40021
#define IDM_PAL_GRAY4                40022
#define IDM_PAL_GRAY8                40023
#define IDM_PAL_GRAY16               40024
#define IDM_PAL_GRAY32               40025
#define IDM_PAL_GRAY64               40026
#define IDM_PAL_GRAY128              40027
#define IDM_PAL_GRAY256              40028
#define IDM_PAL_RGB222               40029
#define IDM_PAL_RGB333               40030
#define IDM_PAL_RGB444               40031
#define IDM_PAL_RGB555               40032
#define IDM_PAL_RGB666               40033
#define IDM_PAL_RGB775               40034
#define IDM_PAL_RGB757               40035
#define IDM_PAL_RGB577               40036
#define IDM_PAL_RGB884               40037
#define IDM_PAL_RGB848               40038
#define IDM_PAL_RGB488               40039
#define IDM_PAL_OPT_POP4             40040
#define IDM_PAL_OPT_POP5             40041
#define IDM_PAL_OPT_POP6             40042
#define IDM_PAL_OPT_MEDCUT           40043
#define IDM_CONVERT_01               40044
#define IDM_CONVERT_04               40045
#define IDM_CONVERT_08               40046
#define IDM_CONVERT_16               40047
#define IDM_CONVERT_24               40048
#define IDM_CONVERT_32               40049
#define IDM_APP_ABOUT                40050

 ï¿½ï¿½Ê½16-24  DIBPAL����
DIBPAL.H
/*--------------------------------------------------------------------------
   	DIBPAL.H header file for DIBPAL.C
----------------------------------------------------------------------------*/

HPALETTE DibPalDibTable (HDIB hdib) ;
HPALETTE DibPalAllPurpose (void) ;
HPALETTE DibPalUniformGrays (int iNum) ;
HPALETTE DibPalUniformColors (int iNumR, int iNumG, int iNumB) ;
HPALETTE DibPalVga (void) ;
HPALETTE DibPalPopularity (HDIB hdib, int iRes) ;
HPALETTE DibPalMedianCut (HDIB hdib, int iRes) ;

DIBPAL.C
/*----------------------------------------------------------------------------
   	DIBPAL.C -- 	Palette-Creation Functions
               						(c) Charles Petzold, 1998
  -------------------------------------------------------------------------*/

#include <windows.h>
#include "dibhelp.h"
#include "dibpal.h"

/*---------------------------------------------------------------------------
   	DibPalDibTable: Creates a palette from the DIB color table
-----------------------------------------------------------------------------*/

HPALETTE DibPalDibTable (HDIB hdib)
{
 	HPALETTE     			hPalette ;
     	int          				i, iNum ;
     	LOGPALETTE 	* 	plp ;
     	RGBQUAD      			rgb ;

     	if (0 == (iNum = DibNumColors (hdib)))
          			return NULL ;
     	plp = malloc (sizeof (LOGPALETTE) + (iNum - 1) * sizeof (PALETTEENTRY)) ;
     	plp->palVersion    		= 0x0300 ;
     	plp->palNumEntries 	= iNum ;

     	for (i = 0 ; i < iNum ; i++)
     	{
          			DibGetColor (hdib, i, &rgb) ;
          			plp->palPalEntry[i].peRed   = rgb.rgbRed ;
          			plp->palPalEntry[i].peGreen = rgb.rgbGreen ;
          			plp->palPalEntry[i].peBlue  = rgb.rgbBlue ;
          			plp->palPalEntry[i].peFlags = 0 ;
     	}
     	hPalette = CreatePalette (plp) ;
     	free (plp) ;
     	return hPalette ;
}
/*---------------------------------------------------------------------------
   	DibPalA	llPurpose: Creates a palette suitable for a wide variety
          				of images; the palette has 247 entries, but 15 of them are 
          				duplicates or match the standard 20 colors.
----------------------------------------------------------------------------*/

HPALETTE DibPalAllPurpose (void)
{
     	HPALETTE     			hPalette ;
     	int          				i, incr, R, G, B ;
     	LOGPALETTE * 	plp ;

     	plp = malloc (sizeof (LOGPALETTE) + 246 * sizeof (PALETTEENTRY)) ;
     	plp->palVersion    		= 0x0300 ;
     	plp->palNumEntries 	= 247 ;

         			// The following loop calculates 31 gray shades, but 3 of them
          			// 			will match the standard 20 colors

     	for (i = 0, G = 0, incr = 8 ; G <= 0xFF ; i++, G += incr)
     {
          			plp->palPalEntry[i].peRed   		= (BYTE) G ;
          			plp->palPalEntry[i].peGreen 	= (BYTE) G ;
          			plp->palPalEntry[i].peBlue  	= (BYTE) G ;
          			plp->palPalEntry[i].peFlags 	= 0 ;

          			incr = (incr == 9 ? 8 : 9) ;
	}

		// The following loop is responsible for 216 entries, but 8 of 
          		//   				them will match the standard 20 colors, and another
          		// 				4 of them will match the gray shades above.

	for (R = 0 ; R <= 0xFF ; R += 0x33)
     	for (G = 0 ; G <= 0xFF ; G += 0x33)
     	for (B = 0 ; B <= 0xFF ; B += 0x33)
     	{
          			plp->palPalEntry[i].peRed   			= (BYTE) R ;
          			plp->palPalEntry[i].peGreen 		= (BYTE) G ;
          			plp->palPalEntry[i].peBlue  		= (BYTE) B ;
          			plp->palPalEntry[i].peFlags 		= 0 ;

          			i++ ;
	}
	hPalette = CreatePalette (plp) ;
	free (plp) ;
	return hPalette ;
}

/*---------------------------------------------------------------------------
	DibPalUniformGrays:  Creates a palette of iNum grays, uniformly spaced
----------------------------------------------------------------------------*/

HPALETTE DibPalUniformGrays (int iNum)
{
     	HPALETTE     			hPalette ;
     	int          				i ;
     	LOGPALETTE 	* 	plp ;

     	plp = malloc (sizeof (LOGPALETTE) + (iNum - 1) * sizeof (PALETTEENTRY)) ;
     	plp->palVersion    			= 0x0300 ;
     	plp->palNumEntries 		= iNum ;

     	for (i = 0 ; i < iNum ; i++)
     	{
          			plp->palPalEntry[i].peRed   		=
          			plp->palPalEntry[i].peGreen 	= 
          			plp->palPalEntry[i].peBlue  	= (BYTE) (i * 255 / (iNum - 1)) ;
          			plp->palPalEntry[i].peFlags = 0 ;
     	}
     	hPalette = CreatePalette (plp) ;
     	free (plp) ;
     	return hPalette ;
}

/*--------------------------------------------------------------------------
	DibPalUniformColors: Creates a palette of iNumR x iNumG x iNumB colors
----------------------------------------------------------------------------*/

HPALETTE DibPalUniformColors (int iNumR, int iNumG, int iNumB)
{
     	HPALETTE     			hPalette ;
     	int          				i, iNum, R, G, B ;
     	LOGPALETTE * 	plp ;

     	iNum = iNumR * iNumG * iNumB ;
     	plp = malloc (sizeof (LOGPALETTE) + (iNum - 1) * sizeof (PALETTEENTRY)) ;
     	plp->palVersion    = 0x0300 ;
     	plp->palNumEntries = iNumR * iNumG * iNumB ;

     	i = 0 ;
     	for (R = 0 ; R < iNumR ; R++)
     	for (G = 0 ; G < iNumG ; G++)
     	for (B = 0 ; B < iNumB ; B++)
     	{
          		plp->palPalEntry[i].peRed   	= (BYTE) (R * 255 / (iNumR - 1)) ;
          		plp->palPalEntry[i].peGreen 	= (BYTE) (G * 255 / (iNumG - 1)) ;
          		plp->palPalEntry[i].peBlue  	= (BYTE) (B * 255 / (iNumB - 1)) ;
          		plp->palPalEntry[i].peFlags 	= 0 ;

          			i++ ;
     	}
     	hPalette = CreatePalette (plp) ;
     	free (plp) ;
     	return hPalette ;
}

/*---------------------------------------------------------------------------
	DibPalVga:  Creates a palette based on standard 16 VGA colors
----------------------------------------------------------------------------*/

HPALETTE DibPalVga (void)
{
	static RGBQUAD rgb [16] = { 0x00, 0x00, 0x00,	0x00,
                                0x00, 0x00, 0x80,	0x00,
                                0x00, 0x80, 0x00,	0x00,
                                0x00, 0x80, 0x80,	0x00,
                                0x80, 0x00, 0x00,	0x00,
                                0x80, 0x00, 0x80,	0x00,
                                0x80, 0x80, 0x00,	0x00,
                                0x80, 0x80, 0x80,	0x00,
                                0xC0, 0xC0, 0xC0,	0x00,
                                0x00, 0x00, 0xFF,	0x00,
                                0x00, 0xFF, 0x00,	0x00,
                                0x00, 0xFF, 0xFF,	0x00,
                                0xFF, 0x00, 0x00,	0x00,
                                0xFF, 0x00, 0xFF,	0x00,
                                0xFF, 0xFF, 0x00,	0x00,
                                0xFF, 0xFF, 0xFF,	0x00 } ;
     	HPALETTE       			hPalette ;
     	int            			i ;
     	LOGPALETTE   		    * 	plp ;

     	plp = malloc (sizeof (LOGPALETTE) + 15 * sizeof (PALETTEENTRY)) ;
     	plp->palVersion    		= 0x0300 ;
     	plp->palNumEntries 	= 16 ;

     	for (i = 0 ; i < 16 ; i++)
     	{
          			plp->palPalEntry[i].peRed   	= rgb[i].rgbRed ;
         			plp->palPalEntry[i].peGreen 	= rgb[i].rgbGreen ;
          			plp->palPalEntry[i].peBlue  	= rgb[i].rgbBlue ;
          			plp->palPalEntry[i].peFlags  = 0 ;
     	}
     	hPalette = CreatePalette (plp) ;
     	free (plp) ;
     	return hPalette ;
}

/*---------------------------------------------------------------------------
   	Macro used in palette optimization routines
  -------------------------------------------------------------------------*/

#define PACK_RGB(R,G,B,iRes) ((int) (R) | 	((int) (G) <<  (iRes)) |	\
                             ((int) (B) << ((iRes) + (iRes))))

/*----------------------------------------------------------------------------
   	AccumColorCounts: Fills up piCount (indexed by a packed RGB color)
    	with counts of pixels of that color.
-----------------------------------------------------------------------------*/

static void AccumColorCounts (HDIB hdib, int * piCount, int iRes)
{
     	int  		x, y, cx, cy ;
     	RGBQUAD	rgb ;

     	cx = DibWidth (hdib) ;
     	cy = DibHeight (hdib) ;

     	for (y = 0 ; y < cy ; y++)
     	for (x = 0 ; x < cx ; x++)
     	{
          			DibGetPixelColor (hdib, x, y, &rgb) ;

          			rgb.rgbRed   	>>= (8 - iRes) ;
          			rgb.rgbGreen 	>>= (8 - iRes) ;
          			rgb.rgbBlue  	>>= (8 - iRes) ;

          			++piCount [PACK_RGB (rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, iRes)] ;
     	}
}

/*---------------------------------------------------------------------------
   	DibPalPopularity:  Popularity algorithm for optimized colors
-----------------------------------------------------------------------------*/

HPALETTE DibPalPopularity (HDIB hdib, int iRes)
{
     	HPALETTE     			hPalette ;
     	int          				i, iArraySize, iEntry, iCount, iIndex, iMask, R, G, B ;
     	int        			* 	piCount ;
     	LOGPALETTE	* 	plp ;

          			// Validity checks
    
     	if (DibBitCount (hdib) < 16)
          			return NULL ;
     	if (iRes < 3 || iRes > 8)
  			return NULL ;
			// Allocate array for counting pixel colors
     	iArraySize = 1 << (3 * iRes) ;
     	iMask = (1 << iRes) - 1 ;

     	if (NULL == (piCount = calloc (iArraySize, sizeof (int))))
          			return NULL ;
          			// Get the color counts
     	AccumColorCounts (hdib, piCount, iRes) ;
          			// Set up a palette
     	plp = malloc (sizeof (LOGPALETTE) + 235 * sizeof (PALETTEENTRY)) ;
     	plp->palVersion = 0x0300 ;
     	for (iEntry = 0 ; iEntry < 236 ; iEntry++)
     	{
          			for (i = 0, iCount = 0 ; i < iArraySize ; i++)
               					if (piCount[i] > iCount)

               					{
                    							iCount = piCount[i] ;
                    							iIndex = i ;
               					}
          			if (iCount == 0)
               					break ;
          			R = (iMask &  iIndex) << (8 - iRes) ;
          	  G = (iMask & (iIndex >> iRes )) << (8 - iRes) ;
          	  B = (iMask & (iIndex >> (iRes + iRes)))<< (8 - iRes) ;

          			plp->palPalEntry[iEntry].peRed   	= (BYTE) R ; 
          			plp->palPalEntry[iEntry].peGreen 	= (BYTE) G ; 
          			plp->palPalEntry[iEntry].peBlue  	= (BYTE) B ; 
          			plp->palPalEntry[iEntry].peFlags 	= 0 ;

          			piCount [iIndex] = 0 ;
     }
          		// On exit from the loop iEntry will be the number of stored entries
     	plp->palNumEntries = iEntry ;
          		// Create the palette, clean up, and return the palette handle
     	hPalette = CreatePalette (plp) ;
     	free (piCount) ;
     	free (plp) ;

     	return hPalette ;
}

/*--------------------------------------------------------------------------
   	Structures used for implementing median cut algorithm
----------------------------------------------------------------------------*/

typedef struct           				// defines dimension of a box
{
     	int Rmin, Rmax, Gmin, Gmax, Bmin, Bmax ;
}
MINMAX ;
typedef struct           				// for Compare routine for qsort
{
     	int     		iBoxCount ;
     	RGBQUAD 	rgbBoxAv ;
}

BOXES ;
/*----------------------------------------------------------------------------
   	FindAverageColor: In a box
-----------------------------------------------------------------------------*/

static int FindAverageColor (	int * piCount, MINMAX mm, 
                             	int iRes, RGBQUAD * prgb)
{
     	int R, G, B, iR, iG, iB, iTotal, iCount ;
          			// Initialize some variables
     	iTotal = iR = iG = iB = 0 ;
          			// Loop through all colors in the box
     	for (R = mm.Rmin ; R <= mm.Rmax ; R++)
     	for (G = mm.Gmin ; G <= mm.Gmax ; G++)
     	for (B = mm.Bmin ; B <= mm.Bmax ; B++)
     	{
               				// Get the number of pixels of that color
          			iCount = piCount [PACK_RGB (R, G, B, iRes)] ;
               				// Weight the pixel count by the color value
          			iR += iCount * R ;
          			iG += iCount * G ;
          			iB += iCount * B ;

          			iTotal += iCount ;
     	}
          			// Find the average color
     	prgb->rgbRed   		= (BYTE) ((iR / iTotal) << (8 - iRes)) ;
     	prgb->rgbGreen 		= (BYTE) ((iG / iTotal) << (8 - iRes)) ;
     	prgb->rgbBlue  		= (BYTE) ((iB / iTotal) << (8 - iRes)) ;

          			// Return the total number of pixels in the box
     
     	return iTotal ;
}

/*---------------------------------------------------------------------------
   CutBox:  Divide a box in two
----------------------------------------------------------------------------*/
static void CutBox (int * piCount, int iBoxCount, MINMAX mm,
                    int iRes, int iLevel, BOXES * pboxes, int * piEntry)
{
     	int    		iCount, R, G, B ;
     	MINMAX 	mmNew ;
     
          			// If the box is empty, return 

     	if (iBoxCount == 0)
          			return ;

          			// If the nesting level is 8, or the box is one pixel, we're ready
          			// to find the average color in the box and save it along with
          			// the number of pixels of that color

     	if (iLevel == 8 || (	mm.Rmin == mm.Rmax && 
                         		mm.Gmin == mm.Gmax && 
                         		mm.Bmin == mm.Bmax))
     {
          		pboxes[*piEntry].iBoxCount = 
       			FindAverageColor (piCount, mm, iRes, &pboxes[*piEntry].rgbBoxAv) ;
          			(*piEntry) ++ ;
     	}
          			// Otherwise, if blue is the largest side, split it
     	else if ((mm.Bmax - mm.Bmin > mm.Rmax - mm.Rmin) && 
              					(mm.Bmax - mm.Bmin > mm.Gmax - mm.Gmin))
     	{
               				// Initialize a counter and loop through the blue side
          		iCount = 0 ;
          		for (B = mm.Bmin ; B < mm.Bmax ; B++)
          		{
                    					// Accumulate all the pixels for each successive blue value
               			for (	R = mm.Rmin ; R <= mm.Rmax ; R++)
               			for (	G = mm.Gmin ; G <= mm.Gmax ; G++)
                    			iCount += piCount [PACK_RGB (R, G, B, iRes)] ;

                    			// If it's more than half the box count, we're there

               			if (i	Count >= iBoxCount / 2)
                    					break ;

                    		//	If the next blue value will be the max, we're there
               							if (	B == mm.Bmax - 1)
                    								break ;
          		}
               				// Cut the two split boxes.
               				//   The second argument to CutBox is the new box count.
               				//   The third argument is the new min and max values.

          		mmNew = mm ;
          		mmNew.Bmin = mm.Bmin ;
          		mmNew.Bmax = B ;

          		CutBox (	piCount, iCount, mmNew, iRes, iLevel + 1, 
                  						pboxes, piEntry) ;

          		mmNew.Bmin = B + 1 ;
          		mmNew.Bmax = mm.Bmax ;

          		CutBox (	piCount, iBoxCount - iCount, mmNew, iRes, iLevel + 1,
                  						pboxes, piEntry) ;
	}
          		// Otherwise, if red is the largest side, split it (just like blue)
     	else if (mm.Rmax - mm.Rmin > mm.Gmax - mm.Gmin)
     {
          		iCount = 0 ;
          		for (R = mm.Rmin ; R < mm.Rmax ; R++)
          		{
               					for (B = mm.Bmin ; B <= mm.Bmax ; B++)
               					for (G = mm.Gmin ; G <= mm.Gmax ; G++)
                    				iCount += piCount [PACK_RGB (R, G, B, iRes)] ;
               					if (iCount >= iBoxCount / 2)
                    							break ;
               					if (R == mm.Rmax - 1)
                    							break ;
     		}
          		mmNew = mm ;
          		mmNew.Rmin = mm.Rmin ;
          		mmNew.Rmax = R ;

          		CutBox (	piCount, iCount, mmNew, iRes, iLevel + 1, 
                  						pboxes, piEntry) ;

          		mmNew.Rmin 	= R + 1 ;
          		mmNew.Rmax 	= mm.Rmax ;
          		CutBox (	piCount, iBoxCount - iCount, mmNew, iRes, iLevel + 1,
                  						pboxes, piEntry) ;
     }
          				// Otherwise, split along the green size
     	else 
     	{
          		iCount = 0 ;
          		for (G = mm.Gmin ; G < mm.Gmax ; G++)
          		{
               			for (	B = mm.Bmin ; B <= mm.Bmax ; B++)
               			for (	R = mm.Rmin ; R <= mm.Rmax ; R++)
                    			iCount += piCount [PACK_RGB (R, G, B, iRes)] ;

               			if (	iCount >= iBoxCount / 2)
                    					break ;

               			if (	G == mm.Gmax - 1)
                    					break ;
         		}
          		mmNew = mm ;
          		mmNew.Gmin = mm.Gmin ;
          		mmNew.Gmax = G ;

          		CutBox (	piCount, iCount, mmNew, iRes, iLevel + 1, 
                  						pboxes, piEntry) ;

          		mmNew.Gmin 	= G + 1 ;
          		mmNew.Gmax 	= mm.Gmax ;

          		CutBox (	piCount, iBoxCount - iCount, mmNew, iRes, iLevel + 1,
                  						pboxes, piEntry) ;
     	}
}

/*---------------------------------------------------------------------------
   	Compare routine for qsort
-----------------------------------------------------------------------------*/

static int Compare (const BOXES * pbox1, const BOXES * pbox2)
{
     	return pbox1->iBoxCount - pbox2->iBoxCount ;
}

/*---------------------------------------------------------------------------
   	DibPalMedianCut:  Creates palette based on median cut algorithm
  -------------------------------------------------------------------------*/
HPALETTE DibPalMedianCut (HDIB hdib, int iRes)
{
     	BOXES        			boxes [256] ;
     	HPALETTE     			hPalette ;
     	int          			i, iArraySize, iCount, R, G, B, iTotCount, iDim, iEntry = 0 ;
     	int        			* 	piCount ;
     	LOGPALETTE 	*	plp ;
     	MINMAX       			mm ;

          			// Validity checks
    
     	if (DibBitCount (hdib) < 16)
          			return NULL ;
     	if (iRes < 3 || iRes > 8)
          			return NULL ;
          			// Accumulate counts of pixel colors
	iArraySize = 1 << (3 * iRes) ;
	if (NULL == (piCount = calloc (iArraySize, sizeof (int))))
          			return NULL ;
	AccumColorCounts (hdib, piCount, iRes) ;
			// Find the dimensions of the total box
	iDim = 1 << iRes ;
	mm.Rmin = mm.Gmin = mm.Bmin = iDim - 1 ;
	mm.Rmax = mm.Gmax = mm.Bmax = 0 ;

	iTotCount = 0 ;
     	for (R = 0 ; R < iDim ; R++)
     	for (G = 0 ; G < iDim ; G++)
     	for (B = 0 ; B < iDim ; B++)
          			if ((iCount = piCount [PACK_RGB (R, G, B, iRes)]) > 0)
          			{
               					iTotCount += iCount ;
               					if (R < mm.Rmin) mm.Rmin = R ;
               					if (G < mm.Gmin) mm.Gmin = G ;
               					if (B < mm.Bmin) mm.Bmin = B ;
               					if (R > mm.Rmax) mm.Rmax = R ;
               					if (G > mm.Gmax) mm.Gmax = G ;
               					if (B > mm.Bmax) mm.Bmax = B ;
          			}

          		// Cut the first box (iterative function).
     		    // 	On return, the boxes structure will have up to 256 RGB values, 
          		// 	one for each of the boxes, and the number of pixels in
          		//  each box.
          		//  The iEntry value will indicate the number of non-empty boxes.

     	CutBox (piCount, iTotCount, mm, iRes, 0, boxes, &iEntry) ;
     	free (piCount) ;

          		// Sort the RGB table by the number of pixels for each color
     	qsort (boxes, iEntry, sizeof (BOXES), Compare) ;
     	plp = malloc (sizeof (LOGPALETTE) + (iEntry - 1) * sizeof (PALETTEENTRY)) ;
     	if (plp == NULL)
          			return NULL ;
     	plp->palVersion    		= 0x0300 ;
     	plp->palNumEntries 	= iEntry ;

     	for (i = 0 ; i < iEntry ; i++)
     	{
          			plp->palPalEntry[i].peRed  = boxes[i].rgbBoxAv.rgbRed ;
          			plp->palPalEntry[i].peGreen= boxes[i].rgbBoxAv.rgbGreen ;
          			plp->palPalEntry[i].peBlue = boxes[i].rgbBoxAv.rgbBlue ;
          			plp->palPalEntry[i].peFlags= 0 ;
     }

	hPalette = CreatePalette (plp) ;
	free (plp) ;
	return hPalette ;
}

 ï¿½ï¿½Ê½16-25  DIBCONV����
DIBCONV.H

/*----------------------------------------------------------------------------
   	DIBCONV.H header file for DIBCONV.C
-----------------------------------------------------------------------------*/

HDIB DibConvert (HDIB hdibSrc, int iBitCountDst) ;

DIBCONV.C
/*---------------------------------------------------------------------------
   	DIBCONV.C --	Converts DIBs from one format to another
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "dibhelp.h"
#include "dibpal.h"
#include "dibconv.h"

HDIB DibConvert (HDIB hdibSrc, int iBitCountDst)
{
     	HDIB         				hdibDst ;
     	HPALETTE     			hPalette ;
     	int          				i, x, y, cx, cy, iBitCountSrc, cColors ;
     	PALETTEENTRY pe ;
     	RGBQUAD      			rgb ;
     	WORD         				wNumEntries ;

     	cx = DibWidth (hdibSrc) ;
     	cy = DibHeight (hdibSrc) ;
     	iBitCountSrc = DibBitCount (hdibSrc) ;

     	if (iBitCountSrc == iBitCountDst)
          			return NULL ;
          		// DIB with color table to DIB with larger color table:
     	if ((iBitCountSrc < iBitCountDst) && (iBitCountDst <= 8))
     	{
          		cColors = DibNumColors (hdibSrc) ;
          		hdibDst = DibCreate (cx, cy, iBitCountDst, cColors) ;

          		for (i = 0 ; i < cColors ; i++)
          		{
               				DibGetColor (hdibSrc, i, &rgb) ;
               				DibSetColor (hdibDst, i, &rgb) ;
          		}

          		for (x = 0 ; x < cx ; x++)
          		for (y = 0 ; y < cy ; y++)
          		{
               		DibSetPixel (hdibDst, x, y, DibGetPixel (hdibSrc, x, y)) ;
          		}
     	}
          		// Any DIB to DIB with no color table
     	else if (iBitCountDst >= 16)
     	{
          		hdibDst = DibCreate (cx, cy, iBitCountDst, 0) ;
          		for (x = 0 ; x < cx ; x++)
          		for (y = 0 ; y < cy ; y++)
          		{
               				DibGetPixelColor (hdibSrc, x, y, &rgb) ;
              	 			DibSetPixelColor (hdibDst, x, y, &rgb) ;
		}
     	}
          		// DIB with no color table to 8-bit DIB
     	else if (iBitCountSrc >= 16 && iBitCountDst == 8)
     	{
          			hPalette = DibPalMedianCut (hdibSrc, 6) ;
          			GetObject (hPalette, sizeof (WORD), &wNumEntries) ;

          			hdibDst = DibCreate (cx, cy, 8, wNumEntries) ;
          			for (i = 0 ; i < (int) wNumEntries ; i++)
          			{
               				GetPaletteEntries (hPalette, i, 1, &pe) ;
               				rgb.rgbRed   			= pe.peRed ;
               				rgb.rgbGreen 			= pe.peGreen ;
               				rgb.rgbBlue  			= pe.peBlue ;
               				rgb.rgbReserved 		= 0 ;

               				DibSetColor (hdibDst, i, &rgb) ;
          			}

          			for (x = 0 ; x < cx ; x++)
          			for (y = 0 ; y < cy ; y++)
          			{
               					DibGetPixelColor (hdibSrc, x, y, &rgb) ;

               					DibSetPixel (hdibDst, x, y,
                    			GetNearestPaletteIndex (hPalette, 
                         		RGB (rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue))) ;
          			}
          			DeleteObject (hPalette) ;
     		}
          				// Any DIB to monochrome DIB

     		else if (iBitCountDst == 1)
     		{
          			hdibDst = DibCreate (cx, cy, 1, 0) ;
          			hPalette = DibPalUniformGrays (2) ;

          			for (i = 0 ; i < 2 ; i++)
          			{
               					GetPaletteEntries (hPalette, i, 1, &pe) ;

               					rgb.rgbRed   = pe.peRed ;
               					rgb.rgbGreen = pe.peGreen ;
               					rgb.rgbBlue  = pe.peBlue ;
               					rgb.rgbReserved = 0 ;

               					DibSetColor (hdibDst, i, &rgb) ;
          			}

          			for (x = 0 ; x < cx ; x++)
          			for (y = 0 ; y < cy ; y++)
          			{
               					DibGetPixelColor (hdibSrc, x, y, &rgb) ;

               					DibSetPixel (hdibDst, x, y,
                    			GetNearestPaletteIndex (hPalette, 
                         		RGB (rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue))) ;
          			}
          			DeleteObject (hPalette) ;
     	}
          			// All non-monochrome DIBs to 4-bit DIB
     	else if (iBitCountSrc >= 8 && iBitCountDst == 4)
     	{
          			hdibDst = DibCreate (cx, cy, 4, 0) ;
          			hPalette = DibPalVga () ;

          			for (i = 0 ; i < 16 ; i++)
          			{
               					GetPaletteEntries (hPalette, i, 1, &pe) ;
               					rgb.rgbRed   				= pe.peRed ;
               					rgb.rgbGreen 			= pe.peGreen ;
               					rgb.rgbBlue  				= pe.peBlue ;
               					rgb.rgbReserved 		= 0 ;

               					DibSetColor (hdibDst, i, &rgb) ;
          			}

          			for (x = 0 ; x < cx ; x++)
          			for (y = 0 ; y < cy ; y++)
          			{
               					DibGetPixelColor (hdibSrc, x, y, &rgb) ;

               				DibSetPixel (hdibDst, x, y,
                    		GetNearestPaletteIndex (hPalette, 
                         	RGB (rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue))) ;
          			}
          			DeleteObject (hPalette) ;
     	}
          			// Should not be necessary
     	else
          			hdibDst = NULL ;
     	return hdibDst ;
}