palette.cpp

Windows 图形编程 书籍

		Label(hDC, 10, 10, "Palette not supported");

	wsprintf(temp, "SIZEPALETTE %d", GetDeviceCaps(hDC, SIZEPALETTE));
	Label(hDC, 10, 30, temp);

	wsprintf(temp, "NUMRESERVED %d", GetDeviceCaps(hDC, NUMRESERVED));
	Label(hDC, 10, 50, temp);

	wsprintf(temp, "COLORRES    %d", GetDeviceCaps(hDC, COLORRES));
	Label(hDC, 10, 70, temp);

	// web colors
	WebColors(hDC, 150,  10, 0);
	WebColors(hDC, 150, 130, 1);
//	WebColors(hDC, 150, 250, 2);

	// default palette
	HPALETTE hPalette = (HPALETTE) GetCurrentObject(hDC, OBJ_PAL);
	
	ShowPalette(hDC, 10, 260, hPalette);

	// colors in system palette
	HDC hMemDC = CreateCompatibleDC(hDC);
	HGDIOBJ hOld;
	{
		BYTE data[80][80];

		for (int i=0; i<80; i++)
		for (int j=0; j<80; j++)
		{
			data[i][j] = (i/5) * 16 + (j/5);
			if ( ((i%5)==0) || ((j%5)==0) )
				data[i][j] = 255;
		}

		HBITMAP hBitmap = CreateBitmap(80, 80, 1, 8, data);

		hOld = SelectObject(hMemDC, hBitmap);

		StretchBlt(hDC, 850, 10, 256, 256, hMemDC, 0, 0, 80, 80, SRCCOPY);

		SelectObject(hMemDC, hOld);
		DeleteObject(hBitmap);
	}

	HBITMAP hBitmap = (HBITMAP) LoadImage(hInstance, MAKEINTRESOURCE(IDB_TIGER2), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_CREATEDIBSECTION);

	hOld = SelectObject(hMemDC, hBitmap);
	BITMAP bmp;
	GetObject(hBitmap, sizeof(bmp), & bmp);

	BitBlt(hDC, 10, 350, bmp.bmWidth, bmp.bmHeight, hMemDC, 0, 0, SRCCOPY);
	
	SelectObject(hMemDC, hOld);
	
	DeleteObject(hBitmap);

	{ // load bitmap using system palette
		HPALETTE hPal = CreateSystemPalette();
		hBitmap = PaletteLoadBitmap(hInstance, MAKEINTRESOURCE(IDB_TIGER2), hPal);
		DeleteObject(hPal);

		hOld = SelectObject(hMemDC, hBitmap);
		BITMAP bmp;
		GetObject(hBitmap, sizeof(bmp), & bmp);

		BitBlt(hDC, 40+bmp.bmWidth, 350, bmp.bmWidth, bmp.bmHeight, hMemDC, 0, 0, SRCCOPY);
	
		SelectObject(hMemDC, hOld);
	
		DeleteObject(hBitmap);
	}

	DeleteObject(hMemDC);
/*
	{
		HDC hDC = GetDC(NULL);

		const WORD ChessBoard88[] = { 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55 };

		HBITMAP hBmp = CreateBitmap(8, 8, 1, 1, ChessBoard88);
		HBRUSH  hBrush = CreatePatternBrush(hBmp);
		HGDIOBJ hOld = SelectObject(hDC, hBrush);
		
		SetBkColor(hDC, 0);							// 1 -> white
		SetTextColor(hDC, RGB(0xFF, 0xFF, 0xFF));	// 0 -> black 
		PatBlt(hDC, 0, 0, GetDeviceCaps(hDC, HORZRES), GetDeviceCaps(hDC, VERTRES), 0xA000C9);
	
		SetBkColor(hDC, RGB(0, 0, 0xFF)); // 1 -> blue
		SetTextColor(hDC, 0);			  // 0 -> white
		PatBlt(hDC, 0, 0, GetDeviceCaps(hDC, HORZRES), GetDeviceCaps(hDC, VERTRES), 0xFA0089);
	
		SelectObject(hDC, hOld);
		DeleteObject(hBrush);
		DeleteObject(hBmp);

		ReleaseDC(NULL, hDC);
	}
*/
}


class KTestView : public KScrollCanvas
{
	virtual void OnDraw(HDC hDC, const RECT * rcPaint)
	{
		switch ( m_nViewOpt )
		{
			case IDM_VIEW_PALETTE:
				TestPalette(hDC, m_hInstance);
				break;

			case IDM_VIEW_HALFTONEPALETTE:
				TestPalette(hDC, m_hInstance, 0);
				break;

			case IDM_VIEW_GRAYSCALEPALETTE:
				TestPalette(hDC, m_hInstance, 1);
				break;

			case IDM_VIEW_GRAYSCALEFULL:
				TestPalette(hDC, m_hInstance, 2);
				break;

			case IDM_VIEW_EXPLICITPALETTE:
				TestPalette(hDC, m_hInstance, 3);
				break;
		}
	}

	virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		switch( uMsg )
		{
			case WM_CREATE:
				m_hWnd		= hWnd;
				m_hViewMenu = LoadMenu(m_hInstance, MAKEINTRESOURCE(IDR_DIBVIEW));
				SetSize(1200, 1200, 5, 5, true);

				return 0;

			case WM_MOUSEMOVE:
				{
					HDC hDC = GetDC(hWnd);

					COLORREF cr = GetPixel(hDC, LOWORD(lParam), HIWORD(lParam));
					TCHAR mess[32];

					wsprintf(mess, "RGB(%02x, %02x, %02x)", GetRValue(cr), GetGValue(cr), GetBValue(cr));
					m_pStatus->SetText(1, mess);
					ReleaseDC(hWnd, hDC);
				}
				return 0;

			case WM_PAINT:
			case WM_SIZE:
			case WM_HSCROLL:
			case WM_VSCROLL:
				return KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);

			case WM_COMMAND:
				switch ( LOWORD(wParam) )
				{
					case IDM_VIEW_PALETTE:
					case IDM_VIEW_HALFTONEPALETTE:
					case IDM_VIEW_GRAYSCALEPALETTE:
					case IDM_VIEW_GRAYSCALEFULL:
					case IDM_VIEW_EXPLICITPALETTE:
						if ( LOWORD(wParam)!= m_nViewOpt )
						{
							m_nViewOpt = LOWORD(wParam);
							SetSize(1000, 1000, 10, 10, true);
							InvalidateRect(hWnd, NULL, TRUE);
						}
						return 0;
				}
				return 0;

			default:
				return CommonMDIChildProc(hWnd, uMsg, wParam, lParam, m_hViewMenu, 3);
		}
	}

	void GetWndClassEx(WNDCLASSEX & wc)
	{
		memset(& wc, 0, sizeof(wc));

		wc.cbSize         = sizeof(WNDCLASSEX);
		wc.style          = CS_HREDRAW | CS_VREDRAW;
		wc.lpfnWndProc    = WindowProc;
		wc.cbClsExtra     = 0;
		wc.cbWndExtra     = 0;       
		wc.hInstance      = NULL;
		wc.hIcon          = LoadIcon(m_hInstance, MAKEINTRESOURCE(IDI_PALETTE));
		wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
		wc.hbrBackground  = (HBRUSH) (COLOR_WINDOW + 1);
		wc.lpszMenuName   = NULL;
		wc.lpszClassName  = NULL;
		wc.hIconSm        = NULL;
	}


	HMENU			m_hViewMenu;
	int				m_nViewOpt;

public:

	HINSTANCE		m_hInstance;

	KTestView(void)
	{
		m_hViewMenu = NULL;
		m_nViewOpt  = IDM_VIEW_PALETTE;
	}

	bool Initialize(HINSTANCE hInstance, KStatusWindow * pStatus)
	{
		m_hInstance = hInstance;
		m_pStatus   = pStatus;

		RegisterClass(_T("TestView"), hInstance);

		return true;
	}

};


BOOL Switch8bpp(void)
{
	HDC hDC = GetDC(NULL);

	int hasPalette = (GetDeviceCaps(hDC, RASTERCAPS) & RC_PALETTE);
	ReleaseDC(NULL, hDC);
	
	if ( hasPalette ) // palette supported
		return TRUE;

	int rslt = MyMessageBox(NULL, "Switch to 256 color mode?", "Palette Window", MB_YESNOCANCEL, IDI_PALETTE);
			
	if ( rslt==IDCANCEL )
		return FALSE;

	if ( rslt==IDYES ) // switch to 8-bpp allowed
	{
		DEVMODE dm;
		dm.dmSize        = sizeof(dm); // important, avoid GPF
		dm.dmDriverExtra = 0;
		EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, & dm); // query current
		dm.dmBitsPerPel = 8;									// set to 8-bpp
		ChangeDisplaySettings(&dm, 0);							// SWITCH
	}
	
	return TRUE;
}


const int Translate[] =
{
	IDM_FILE_CLOSE,
	IDM_FILE_EXIT,
	IDM_WINDOW_TILE,
	IDM_WINDOW_CASCADE,
	IDM_WINDOW_ARRANGE,
	IDM_WINDOW_CLOSEALL
};


class KMyMDIFRame : public KMDIFrame
{
	KToolbarB *     m_pToolbarB;

	int				m_nCount;
	HWND			m_Children[100];
	int				m_nChild;

	KPaletteWnd     m_palettewnd;

	KDIBWindow	    dibwindow1;
	KDIBWindow	    dibwindow2;
	KDIBWindow	    dibwindow3;

	KDIBWindow	    dibwindow4;
	KDIBWindow	    dibwindow5;
	KDIBWindow	    dibwindow6;

	void CreateMDIChild(KScrollCanvas * canvas, const TCHAR * klass, const TCHAR * filename, const TCHAR * title)
	{
		MDICREATESTRUCT mdic;

		TCHAR Temp[MAX_PATH];

		if ( ! canvas->GetTitle(filename, Temp) )
		{
			m_nCount ++;
			wsprintf(Temp, title, m_nCount);
		}

		mdic.szClass = klass;
		mdic.szTitle = Temp;
		mdic.hOwner  = m_hInst;
		mdic.x       = CW_USEDEFAULT;
		mdic.y       = CW_USEDEFAULT;
		mdic.cx      = CW_USEDEFAULT;
		mdic.cy      = CW_USEDEFAULT;
		mdic.style   = WS_VISIBLE | WS_BORDER;
		mdic.lParam  = (LPARAM) canvas;

		HWND hWnd = (HWND) SendMessage(m_hMDIClient, WM_MDICREATE, 0, (LPARAM) & mdic);

		if ( hWnd )
			m_Children[m_nChild++] = hWnd;
	}

	void CreateDIBView(const TCHAR * pFileName)
	{
		KDIBView * pDIBView = new KDIBView();

		if ( pDIBView )
			if ( pDIBView->Initialize(pFileName, m_hInst, m_pStatus, m_hWnd) )
				CreateMDIChild(pDIBView, _T("DIBView"), pFileName, _T("DIB %d"));
			else
				delete pDIBView;
	}

	void CreateDIBView(BITMAPINFO * pDIB, const TCHAR * pTitle)
	{
		KDIBView * pDIBView = new KDIBView();

		if ( pDIBView )
			if ( pDIBView->Initialize(pDIB, m_hInst, m_pStatus, m_hWnd) )
				CreateMDIChild(pDIBView, _T("DIBView"), pTitle, _T("DIB %d"));
			else
				delete pDIBView;
	}


	void CreateTestView(void)
	{
		KTestView * pTestView = new KTestView();

		if ( pTestView )
			if ( pTestView->Initialize(m_hInst, m_pStatus) )
				CreateMDIChild(pTestView, _T("TestView"), NULL, _T("Test %d"));
			else
				delete pTestView;
	}
	
	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam)
	{
		switch ( LOWORD(wParam) )
		{
			case IDM_FILE_NEW:
				CreateDIBView(NULL);
				return TRUE;

			case IDM_FILE_TEST:
				CreateTestView();
				return TRUE;

			case IDM_FILE_OPEN:
			{
				KFileDialog fo;

				if ( fo.GetOpenFileName(m_hWnd, "bmp", "Bitmap Files") )
					CreateDIBView(fo.m_TitleName);
				
				return TRUE;
			}

			case IDM_FILE_PALETTEWND:
			{
				m_palettewnd.CreatePaletteWindow(m_hInst);
				return TRUE;
			}

			case IDM_FILE_PALMESSAGE:
			{
				HRSRC hRes = FindResource(m_hInst, MAKEINTRESOURCE(IDB_TIGER1), RT_BITMAP);
				HGLOBAL hGlobal = LoadResource(m_hInst, hRes);
				BITMAPINFO * pDIB = (BITMAPINFO *) LockResource(hGlobal);

				if ( pDIB )
				{
					dibwindow1.CreateDIBWindow(m_hInst, pDIB, 
						(const BYTE *) & pDIB->bmiColors[GetDIBColorCount( pDIB->bmiHeader)], pal_no);

					dibwindow2.CreateDIBWindow(m_hInst, pDIB, 
						(const BYTE *) & pDIB->bmiColors[GetDIBColorCount( pDIB->bmiHeader)], pal_halftone);

					dibwindow3.CreateDIBWindow(m_hInst, pDIB, 
						(const BYTE *) & pDIB->bmiColors[GetDIBColorCount( pDIB->bmiHeader)], pal_halftone | pal_react);
				}

				return TRUE;
			}
 
			case IDM_FILE_DIBPAL:
			{
				dibwindow4.CreateDIBWindow(m_hInst, MAKEINTRESOURCE(IDB_FLOWER), 
					pal_halftone | pal_react);

				dibwindow5.CreateDIBWindow(m_hInst, MAKEINTRESOURCE(IDB_FLOWER), 
					pal_halftone | pal_stretchHT | pal_react);
				
				dibwindow6.CreateDIBWindow(m_hInst, MAKEINTRESOURCE(IDB_FLOWER), 
					pal_bitmap | pal_react);
				
				return TRUE;
			}
		}

		return FALSE; // not processed
	}

	virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		switch ( uMsg )
		{
			case WM_USER:
				CreateDIBView((BITMAPINFO *) wParam, (const TCHAR *) lParam);
				return 0;

			case WM_PALETTECHANGED:
				{
					if ( hWnd != (HWND) wParam )
						for (int i=0; i<m_nChild; i++)
							SendMessage(m_Children[i], uMsg, wParam, lParam);

					m_pToolbarB->SetBitmap(m_hInst, IDR_277);
				}
				return 0;

			default:
			{
				LRESULT lr = KMDIFrame::WndProc(hWnd, uMsg, wParam, lParam);
				if ( uMsg == WM_CREATE )
					m_pToolbarB->SetBitmap(m_hInst, IDR_277);

				return lr;
			}
		}
	}

	void GetWndClassEx(WNDCLASSEX & wc)
	{
		KMDIFrame::GetWndClassEx(wc);

		wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_PALETTE));
	}

public:
	KMyMDIFRame(HINSTANCE hInstance, const TBBUTTON * pButtons, int nCount,
		KToolbarB * pToolbar, KStatusWindow * pStatus) :
		KMDIFrame(hInstance, pButtons, nCount, pToolbar, pStatus, Translate)
	{
		m_pToolbarB = pToolbar;
		m_nCount    = 0;
		m_nChild    = 0;
	}
};


const TBBUTTON tbButtons[] =
{
	{ STD_FILENEW,	 IDM_FILE_NEW,   TBSTATE_ENABLED, TBSTYLE_BUTTON, { 0, 0 }, IDS_FILENEW,  0 },
	{ STD_FILEOPEN,  IDM_FILE_OPEN,  TBSTATE_ENABLED, TBSTYLE_BUTTON, { 0, 0 }, IDS_FILEOPEN, 0 }
};



HPALETTE CreateDIBSectionPalette(HDC hDC, HBITMAP hDIBSec)
{
	HDC hMemDC   = CreateCompatibleDC(hDC);
	HGDIOBJ hOld = SelectObject(hMemDC, hDIBSec);

	RGBQUAD Color[256];

	int nEntries = GetDIBColorTable(hMemDC, 0, 256, Color);

	HPALETTE hPal = LUTCreatePalette((BYTE *) Color, sizeof(RGBQUAD), nEntries);

	SelectObject(hMemDC, hOld);
	DeleteObject(hMemDC);
	
	return hPal;
}


int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int nShow)
{
	KToolbarB     toolbar;
	KStatusWindow status;

	KDIBWindow	  dibwindow5;

	KMyMDIFRame frame(hInst, tbButtons, 2, & toolbar, & status);

	TCHAR title[MAX_PATH];

	_tcscpy(title, "Palette");

	frame.CreateEx(0, _T("ClassName"), title,
		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
	    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
	    NULL, LoadMenu(hInst, MAKEINTRESOURCE(IDR_MAIN)), hInst);

    frame.ShowWindow(nShow);
    frame.UpdateWindow();

    frame.MessageLoop();

	return 0;
}