第一个类：
// Picture.h: interface for the CPicture class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_PICTURE_H__6098A4C3_D6D5_4711_BC7B_1595F459B480__INCLUDED_)
#define AFX_PICTURE_H__6098A4C3_D6D5_4711_BC7B_1595F459B480__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CPicture  
{
public:
CPicture();
virtual ~CPicture();

bool Load(CString sResourceType, CString sResource);
bool Load(CString sFileName);
bool Draw(CDC* pDC);
bool Draw(CDC* pDC, CPoint Pos);
bool Draw(CDC* pDC, CPoint Pos, CSize Size);
bool Draw(CDC* pDC, double nSizeRatio);
bool Draw(CDC* pDC, CPoint Pos, double nSizeRatio);

bool Draw(CDC* pDC, RECT rect);
CSize GetSize(CDC* pDC);
private:
static bool GetResource(LPSTR lpName, LPSTR lpType, void* pResource, int& nBufSize);
void UnLoad();
bool LoadFromBuffer(BYTE* pBuff, int nSize);
bool Draw(CDC* pDC, int x, int y, int cx, int cy);
IPicture* m_pPicture;
enum
{
HIMETRIC_INCH = 2540
};
};

#endif // !defined(AFX_PICTURE_H__6098A4C3_D6D5_4711_BC7B_1595F459B480__INCLUDED_)
//
// Picture.cpp: implementation of the CPicture class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Picture.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPicture::CPicture()
{
m_pPicture = NULL;
}

CPicture::~CPicture()
{
UnLoad();
}

bool CPicture::Load(CString sResourceType, CString sResource)
{
bool bResult = false;

if (m_pPicture != NULL)
UnLoad();

if (m_pPicture == NULL)
{
BYTE* pBuff = NULL;
int nSize = 0;
if (GetResource(sResource.GetBuffer(0), sResourceType.GetBuffer(0), pBuff, nSize))
{
if (nSize > 0)
{
pBuff = new BYTE[nSize];

if (GetResource(sResource.GetBuffer(0), sResourceType.GetBuffer(0), pBuff, nSize))
{
if (LoadFromBuffer(pBuff, nSize))
bResult = true;
}

delete [] pBuff;
}
}
}
return bResult;
}

bool CPicture::Load(CString sFileName)
{
bool bResult = false;

if (m_pPicture != NULL)
UnLoad();

if (m_pPicture == NULL)
{
CFile cFile;
CFileException e;

if (cFile.Open(sFileName, CFile::modeRead | CFile::typeBinary, &e))
{
BYTE* pBuff = new BYTE[cFile.GetLength()];

if (cFile.Read(pBuff, cFile.GetLength()) > 0)
{
if (LoadFromBuffer(pBuff, cFile.GetLength()))
bResult = true;
}

delete [] pBuff;
}
}
return bResult;
}

void CPicture::UnLoad()
{
if (m_pPicture != NULL)
{
m_pPicture->Release();
m_pPicture = NULL;
}
}

bool CPicture::Draw(CDC* pDC)
{
if (m_pPicture != NULL)
{
long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

int nWidth = MulDiv(hmWidth, pDC->GetDeviceCaps(LOGPIXELSX), HIMETRIC_INCH);
int nHeight = MulDiv(hmHeight, pDC->GetDeviceCaps(LOGPIXELSY), HIMETRIC_INCH);

return Draw(pDC, 0, 0, nWidth, nHeight);
}
return false;
}

bool CPicture::Draw(CDC* pDC, CPoint Pos)
{
if (m_pPicture != NULL)
{
long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

int nWidth = MulDiv(hmWidth, pDC->GetDeviceCaps(LOGPIXELSX), HIMETRIC_INCH);
int nHeight = MulDiv(hmHeight, pDC->GetDeviceCaps(LOGPIXELSY), HIMETRIC_INCH);

return Draw(pDC, Pos.x, Pos.y, nWidth, nHeight);
}
return false;
}

bool CPicture::Draw(CDC* pDC, CPoint Pos, CSize Size)
{
if (m_pPicture != NULL)
{
long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

int nWidth = Size.cx;
int nHeight = Size.cy;

return Draw(pDC, Pos.x, Pos.y, nWidth, nHeight);
}
return false;
}

bool CPicture::Draw(CDC* pDC, double nSizeRatio)
{
if (m_pPicture != NULL)
{
long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

int nWidth = int(MulDiv(hmWidth, pDC->GetDeviceCaps(LOGPIXELSX), HIMETRIC_INCH) * nSizeRatio);
int nHeight = int(MulDiv(hmHeight, pDC->GetDeviceCaps(LOGPIXELSY), HIMETRIC_INCH) * nSizeRatio);

return Draw(pDC, 0, 0, nWidth, nHeight);
}
return false;
}

bool CPicture::Draw(CDC* pDC, CPoint Pos, double nSizeRatio)
{
if (m_pPicture != NULL)
{
long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

int nWidth = int(MulDiv(hmWidth, pDC->GetDeviceCaps(LOGPIXELSX), HIMETRIC_INCH) * nSizeRatio);
int nHeight = int(MulDiv(hmHeight, pDC->GetDeviceCaps(LOGPIXELSY), HIMETRIC_INCH) * nSizeRatio);

return Draw(pDC, Pos.x, Pos.y, nWidth, nHeight);
}
return false;
}

bool CPicture::Draw(CDC* pDC, int x, int y, int cx, int cy)
{
long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

if (m_pPicture->Render(pDC->m_hDC, x, y, cx, cy, 0, hmHeight, hmWidth, -hmHeight, NULL) == S_OK)
return true;

return false;
}

bool CPicture::Draw(CDC* pDC, RECT rect)
{
CPoint p;
p.x = rect.left;
p.y = rect.top;

CSize size;
size.cx = rect.right;
size.cy = rect.bottom;

return Draw(pDC, p, size);
}

bool CPicture::LoadFromBuffer(BYTE* pBuff, int nSize)
{
bool bResult = false;

HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, nSize);
void* pData = GlobalLock(hGlobal);
memcpy(pData, pBuff, nSize);
GlobalUnlock(hGlobal);

IStream* pStream = NULL;

if (CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) == S_OK)
{
HRESULT hr;
if ((hr = OleLoadPicture(pStream, nSize, FALSE, IID_IPicture, (LPVOID *)&m_pPicture)) == S_OK)
bResult = true;

pStream->Release();
}

return bResult;
}

bool CPicture::GetResource(LPSTR lpName, LPSTR lpType, void* pResource, int& nBufSize)
{ 
HRSRC hResInfo;
HANDLE hRes;
HMODULE hInst = NULL; 
LPSTR lpRes = NULL; 
int nLen = 0;
bool bResult = FALSE;

// Find the resource
hResInfo = FindResource(hInst, lpName, lpType);

if (hResInfo == NULL) 
return false;

// Load the resource
hRes = LoadResource(hInst, hResInfo);

if (hRes == NULL) 
return false;

// Lock the resource
lpRes = (char*)LockResource(hRes);

if (lpRes != NULL)
{ 
if (pResource == NULL)
{
nBufSize = SizeofResource(hInst, hResInfo);
bResult = true;
}
else
{
if (nBufSize >= (int)SizeofResource(hInst, hResInfo))
{
memcpy(pResource, lpRes, nBufSize);
bResult = true;
}
} 

UnlockResource(hRes);  
}

// Free the resource
FreeResource(hRes);

return bResult;
}

CSize CPicture::GetSize(CDC* pDC)
{
CSize rcResult = CSize(0,0);

if (m_pPicture != NULL)
{
long hmWidth;
long hmHeight;
m_pPicture->get_Width(&hmWidth);
m_pPicture->get_Height(&hmHeight);

rcResult.cx = MulDiv(hmWidth, pDC->GetDeviceCaps(LOGPIXELSX), HIMETRIC_INCH);
rcResult.cy = MulDiv(hmHeight, pDC->GetDeviceCaps(LOGPIXELSY), HIMETRIC_INCH);
}

return rcResult;
}

第二个类：
#if !defined(AFX_ImageStatic_H__295803DC_AF65_11D6_9CC2_0001028665B7__INCLUDED_)
#define AFX_ImageStatic_H__295803DC_AF65_11D6_9CC2_0001028665B7__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// ImageStatic.h : header file
//

#include "Picture.h"

/////////////////////////////////////////////////////////////////////////////
// CImageStatic window

class CImageStatic : public CStatic
{
// Construction
public:
CImageStatic();

// Attributes
public:

// Operations
public:

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CImageStatic)
//}}AFX_VIRTUAL

// Implementation
public:
void DoPaint(BOOL bImage);
BOOL HideImage();
BOOL ShowImage(LPCTSTR lpszPathName);
virtual ~CImageStatic();

// Generated message map functions
protected:
//{{AFX_MSG(CImageStatic)
afx_msg void OnPaint();
//}}AFX_MSG

DECLARE_MESSAGE_MAP()
private:
CPicture m_Picture;
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_BMPSTATIC_H__295803DC_AF65_11D6_9CC2_0001028665B7__INCLUDED_)

//////////////////////////////////////
// ImageStatic.cpp : implementation file
//

#include "stdafx.h"
#include "ImageStatic.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CImageStatic

CImageStatic::CImageStatic()
{
}

CImageStatic::~CImageStatic()
{
}


BEGIN_MESSAGE_MAP(CImageStatic, CStatic)
//{{AFX_MSG_MAP(CImageStatic)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CImageStatic message handlers

BOOL CImageStatic::ShowImage(LPCTSTR lpszPathName)
{
BOOL bSuccess = m_Picture.Load(lpszPathName);
DoPaint(bSuccess);
return true;
}

BOOL CImageStatic::HideImage()
{
DoPaint(FALSE);
return true;
}

void CImageStatic::DoPaint(BOOL bImage)
{
RECT ClientRect;
GetClientRect(&ClientRect);
CClientDC dc(this);

CDC* pDc = GetDC();

//ÈôΪÕ棬»æÖÆλͼ
if(bImage)
{
m_Picture.Draw(pDc, ClientRect);
}
else //·ñÔò£¬Ìî³ä°×É«
{
CBrush* pBrush;
pBrush = CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH));
dc.FillRect(&ClientRect, pBrush);
}
}

void CImageStatic::OnPaint() 
{
CPaintDC dc(this); // device context for painting

// TODO: Add your message handler code here
DoPaint(TRUE);

// Do not call CStatic::OnPaint() for painting messages
}

//你将上面四个文件包含到你的工程中，下面是用法：
#include "ImageStatic.h"
CImageStatic imageStatic;

void CMyView::OnFileOpen() 
{
CFileDialog* pFileDlg;
pFileDlg = new CFileDialog(TRUE, NULL, NULL,OFN_HIDEREADONLY |
OFN_OVERWRITEPROMPT,"bmp and jpg Files (*.bmp,*.jpg)|*.bmp;*.jpg|jpeg files(*.jpeg)|*.jpeg|All files(*.*)|*.*",this);
if(pFileDlg->DoModal() == IDOK)
{
CString str = pFileDlg->GetPathName();
imageStatic.ShowImage(str);

}

if(pFileDlg)
delete pFileDlg;
}

up

现在我这就有源程序！