bitmaps.cpp

Windows 图形编程 书籍

	}
}


class KRipDialog : public KDialog
{
	int m_width;
	int m_height;

    virtual BOOL DlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
    	switch (uMsg)
	    {
		    case WM_INITDIALOG:
				{
					for (int i=1; i<10; i++)
					{
						TCHAR mess[64];

						wsprintf(mess, "%d%c % %d x %d pixels, %d Kb", i*100, '%', i*m_width, i*m_height,
							(m_width*i*3+3)/4*4*m_height*i/1024);
						SendDlgItemMessage(hWnd, IDC_LIST, LB_ADDSTRING, 0, (LPARAM) mess);
						SendDlgItemMessage(hWnd, IDC_LIST, LB_SETCURSEL, 0, 0);
					}
				}
				return TRUE;
	
		    case WM_COMMAND:
				if ( LOWORD(wParam)==IDOK )
				{
					EndDialog(hWnd, 1 + SendDlgItemMessage(hWnd, IDC_LIST, LB_GETCURSEL, 0, 0));
					return TRUE;
				}
				else if ( LOWORD(wParam)==IDCANCEL )
				{
					EndDialog(hWnd, 0);
					return TRUE;
				}
	    }

	    return FALSE;
    }

public:
	KRipDialog(int width, int height)
	{
		m_width  = width;
		m_height = height;
	}
};


BOOL RenderEMF(HINSTANCE hInstance)
{
	KFileDialog fd;

	if ( ! fd.GetOpenFileName(NULL, "emf", "Enhanced Metafiles") )
		return FALSE;

	HENHMETAFILE hemf = GetEnhMetaFile(fd.m_TitleName);

	if ( hemf==NULL )
		return FALSE;

	if ( ! fd.GetSaveFileName(NULL, "tga", "Targa 24 bit Image") )
	{
		DeleteEnhMetaFile(hemf);
		return FALSE;
	}

	ENHMETAHEADER emfheader;

	GetEnhMetaFileHeader(hemf, sizeof(ENHMETAHEADER), & emfheader);

	int width  = emfheader.rclBounds.right  - emfheader.rclBounds.left;
	int height = emfheader.rclBounds.bottom - emfheader.rclBounds.top;

	KRipDialog sizedialog(width, height);

	int scale = sizedialog.Dialogbox(hInstance, MAKEINTRESOURCE(IDD_RIP), NULL);
	BOOL rslt;

	if ( scale )
		rslt = RenderEMF(hemf, width * scale, height * scale, fd.m_TitleName);
	else
		rslt = FALSE;

	DeleteEnhMetaFile(hemf);

	return rslt;
}


void KDIBSectionView::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_hInst, MAKEINTRESOURCE(IDI_IMAGE));
	wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground  = (HBRUSH) GetStockObject(WHITE_BRUSH);
	wc.lpszMenuName   = NULL;
	wc.lpszClassName  = NULL;
	wc.hIconSm        = NULL;
}


LRESULT KDIBSectionView::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch( uMsg )
	{
		case WM_CREATE:
			m_hWnd		= hWnd;
			m_hViewMenu = LoadMenu(m_hInst, MAKEINTRESOURCE(IDR_DIBSECTIONVIEW));
			return 0;

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

		case WM_SIZE:
		case WM_HSCROLL:
		case WM_VSCROLL:
		{
			LRESULT lr = KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);

			int nMin, nMax, nPos;

			GetScrollRange(m_hWnd, SB_VERT, &nMin, &nMax);

			nPos = GetScrollPos(m_hWnd, SB_VERT);

			TCHAR mess[32];
			wsprintf(mess, "%d %d %d", nMin, nPos, nMax);
			m_pStatus->SetText(0, mess);

			return lr;
		}

		case WM_COMMAND:
			switch ( LOWORD(wParam) )
			{
				case IDM_VIEW_CREATEDIBSECTION:
					if ( LOWORD(wParam)!= m_nViewOpt )
					{
						m_nViewOpt = LOWORD(wParam);

						InvalidateRect(hWnd, NULL, TRUE);
					}
					return 0;

				case IDM_VIEW_RIP:
					RenderEMF(m_hInst);
					return 0;
			}
	}

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


void KDIBSectionView::OnDraw(HDC hDC, const RECT * rcPaint)
{
	switch ( m_nViewOpt )
	{
		case IDM_VIEW_CREATEBITMAP:
			Test_CreateDIBSection(hDC, rcPaint);
			break;
	}
}


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
{
	int				m_nCount;
	KDDBBackground  m_background;

	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;

		SendMessage(m_hMDIClient, WM_MDICREATE, 0, (LPARAM) & mdic);
	}

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

		if ( pDIBView )
			if ( pDIBView->Initialize(pFileName, m_hInst, m_pStatus) )
				CreateMDIChild(pDIBView, _T("DIBView"), pFileName, _T("DIB %d"));
			else
				delete pDIBView;
	}
	
	void CreateDDBView(void)
	{
		KDDBView * pDDBView = new KDDBView();

		if ( pDDBView )
			if ( pDDBView->Initialize(m_hInst, m_pStatus) )
				CreateMDIChild(pDDBView, _T("DDBView"), NULL, _T("DDB %d"));
			else
				delete pDDBView;
	}

	void CreateDIBSectionView(void)
	{
		KDIBSectionView * pDIBSectionView = new KDIBSectionView();

		if ( pDIBSectionView )
			if ( pDIBSectionView->Initialize(m_hInst, m_pStatus) )
				CreateMDIChild(pDIBSectionView, _T("DIBSectionView"), NULL, _T("DIBSection %d"));
			else
				delete pDIBSectionView;
	}

	void CreateHexView(WPARAM wParam, LPARAM lParam)
	{
		KEditView * pEditView = new KEditView();

		if ( pEditView )
			if ( pEditView->Initialize(m_hInst) )
			{
				CreateMDIChild(pEditView, _T("EditView"), NULL, _T("Hex Dump %d"));
				pEditView->Decode(wParam, lParam);
			}
			else
				delete pEditView;
	}

	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam)
	{
		switch ( LOWORD(wParam) )
		{
			case IDM_FILE_NEW:
				CreateDIBView(NULL);
				return TRUE;

			case IDM_FILE_NEWDDB:
				CreateDDBView();
				return TRUE;

			case IDM_FILE_NEW_DIBSECTION:
				CreateDIBSectionView();
				return TRUE;

			case IDM_FILE_OPEN:
			{
				KFileDialog fo;

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

		return FALSE; // not processed
	}

	virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		if ( uMsg==WM_USER + 1)
		{
			CreateHexView(wParam, lParam);
			return 0;
		}
		
		LRESULT lr = KMDIFrame::WndProc(hWnd, uMsg, wParam, lParam);

		if ( uMsg == WM_CREATE )
		{
			m_background.SetBitmap(m_hInst, IDB_PUZZLE);
			m_background.Attach(m_hMDIClient);
		}

		return lr;
	}

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

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

public:
	KMyMDIFRame(HINSTANCE hInstance, const TBBUTTON * pButtons, int nCount,
		KToolbar * pToolbar, KStatusWindow * pStatus) :
		KMDIFrame(hInstance, pButtons, nCount, pToolbar, pStatus, Translate)
	{
		m_nCount = 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 }
};


class KMyDialog : public KDialog
{
	KDDBBackground whole;
	KDDBBackground groupbox;
	KDDBBackground frame;
	KDDBBackground button;

	HINSTANCE      m_hInstance;

    virtual BOOL DlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
    	switch (uMsg)
	    {
		    case WM_INITDIALOG:
				m_hWnd = hWnd;
				
				whole.SetBitmap(m_hInstance, IDB_PAPER01);
				whole.SetStyle(KDDB::draw_tile);
				whole.Attach(hWnd);
				
				groupbox.SetBitmap(m_hInstance, IDB_BRICK02);
				groupbox.SetStyle(KDDB::draw_center);
				groupbox.Attach(GetDlgItem(hWnd, IDC_GROUPBOX));

				frame.SetBitmap(m_hInstance, IDB_BRICK02);
				frame.SetStyle(KDDB::draw_stretchprop);
				frame.Attach(GetDlgItem(hWnd, IDC_FRAME)); 
				return TRUE;
	
		    case WM_COMMAND:
				if ( LOWORD(wParam)==IDOK )
				{
					EndDialog(hWnd, 1);
					return TRUE;
				}
	    }

	    return FALSE;
    }

public:
	KMyDialog(HINSTANCE hInst)
	{
		m_hInstance = hInst;
	}
};


int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int nShow)
{
	KToolbar      toolbar;
	KStatusWindow status;
	KMyDialog	  testdialog(hInst);

	testdialog.Dialogbox(hInst, MAKEINTRESOURCE(IDD_BACKGROUND), NULL);

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

	TCHAR title[MAX_PATH];

	HDC hDC = GetDC(NULL);
	wsprintf(title, "DIBShop (%s)", PixelFormatName(PixelFormat(hDC)));
	ReleaseDC(NULL, hDC);

	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;
}