www.pudn.com > 毕业留念册.rar > Dib.cpp

// Dib.cpp: implementation of the CDib class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
#include "Browse.h" 
#include "Dib.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
#include "Dib.h" 
#include "Mmsystem.h" 
#include "math.h" 
#include "Jpeg.h" 
CDib::CDib() 
{ 
	m_hDib = NULL; 
	m_pPalette = NULL; 
	m_Index=0; 
} 
 
CDib::~CDib() 
{ 
	if ( m_hDib != NULL) 
		GlobalFree(m_hDib); 
	if ( m_pPalette != NULL) 
	{ 
		delete m_pPalette; 
		m_pPalette = NULL; 
	} 
} 
 
BOOL CDib::Read(CFile *pFile) 
{ 
	BITMAPFILEHEADER bmfHeader; 
	DWORD dwBitsSize; 
	LPSTR pDIB; 
 
	dwBitsSize = pFile->GetLength(); 
 
	if (pFile->Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader)) 
		return FALSE; 
 
	if (bmfHeader.bfType != DIB_HEADER_MARKER) 
		return NULL; 
 
	m_hDib = (HDIB)GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBitsSize); 
	if (m_hDib == 0) 
	{ 
		return FALSE; 
	} 
	pDIB = (LPSTR)GlobalLock(m_hDib); 
 
	if (pFile->ReadHuge(pDIB, dwBitsSize - sizeof(BITMAPFILEHEADER)) != 
		dwBitsSize - sizeof(BITMAPFILEHEADER) ) 
	{ 
		GlobalUnlock(m_hDib); 
		GlobalFree(m_hDib); 
		return FALSE; 
	} 
	GlobalUnlock(m_hDib); 
	return TRUE; 
} 
 
 
DWORD CDib::DIBWidth(LPSTR lpDIB) 
{ 
	LPBITMAPINFOHEADER lpbmi;   
	LPBITMAPCOREHEADER lpbmc;   
 
	lpbmi = (LPBITMAPINFOHEADER)lpDIB; 
	lpbmc = (LPBITMAPCOREHEADER)lpDIB; 
 
	if (IS_WIN30_DIB(lpDIB)) 
		return lpbmi->biWidth; 
	else 
		return (DWORD)lpbmc->bcWidth; 
} 
 
 
DWORD CDib::GetWidth() 
{ 
	if(m_hDib == NULL) 
		return 0; 
	LPSTR lpDIB = (LPSTR)GlobalLock(m_hDib); 
	return DIBWidth(lpDIB); 
}	 
 
 
DWORD CDib::DIBHeight(LPSTR lpDIB) 
{ 
	LPBITMAPINFOHEADER lpbmi;   
	LPBITMAPCOREHEADER lpbmc;   
 
	lpbmi = (LPBITMAPINFOHEADER)lpDIB; 
	lpbmc = (LPBITMAPCOREHEADER)lpDIB; 
 
 
	if (IS_WIN30_DIB(lpDIB)) 
		return lpbmi->biHeight; 
	else  
		return (DWORD)lpbmc->bcHeight; 
} 
 
 
DWORD CDib::GetHeight() 
{	 
	if(m_hDib == NULL) 
		return 0; 
	LPSTR lpDIB = (LPSTR)GlobalLock(m_hDib); 
	return DIBHeight(lpDIB); 
} 
 
HPALETTE CDib::CreateDIBPalette(LPBITMAPINFOHEADER lpbi) 
{ 
	LPLOGPALETTE      lpPal;	 
	HANDLE			  hLogPal;	 
	HPALETTE		  hPal = NULL;	 
	int				  i, wNumColors;	 
	LPBITMAPINFO	  lpbmi; 
	 
 
	if ( ! lpbi) 
		return NULL; 
 
	lpbmi = (LPBITMAPINFO)lpbi; 
 
	wNumColors = DIBNumColors((LPSTR)lpbi); 
 
	if (wNumColors) 
	{ 
 
		hLogPal = GlobalAlloc(GHND, sizeof(LOGPALETTE) + 
			sizeof(PALETTEENTRY) * wNumColors); 
 
		if ( !hLogPal) 
			return NULL; 
 
		lpPal = (LPLOGPALETTE)GlobalLock(hLogPal); 
 
		lpPal->palVersion = PALVERSION; 
		lpPal->palNumEntries = wNumColors; 
 
		for ( i = 0; i < wNumColors; i++) 
		{ 
			lpPal->palPalEntry[i].peRed =  lpbmi->bmiColors[i].rgbRed; 
			lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen; 
			lpPal->palPalEntry[i].peBlue =  lpbmi->bmiColors[i].rgbBlue; 
			lpPal->palPalEntry[i].peFlags = 0; 
		} 
 
		hPal = CreatePalette(lpPal); 
		if (!hPal) 
		{ 
			GlobalUnlock(hLogPal); 
			GlobalFree(hLogPal); 
			return NULL; 
		} 
	} 
 
	GlobalUnlock(hLogPal); 
	GlobalFree(hLogPal); 
 
	return hPal; 
} 
 
 
BOOL CDib::BuildPalette() 
{ 
	if (m_pPalette != NULL) 
	{ 
		delete m_pPalette; 
		m_pPalette = NULL; 
	} 
	LPBITMAPINFOHEADER lpbi; 
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(m_hDib); 
	HPALETTE hPalette = CreateDIBPalette(lpbi); 
	if (hPalette == NULL) 
		return FALSE; 
	m_pPalette = new CPalette; 
	m_pPalette->Attach(hPalette); 
	return TRUE; 
} 
 
 
WORD CDib::DIBNumColors(LPSTR lpDIB) 
{ 
	WORD wBitCount; 
 
	if(IS_WIN30_DIB(lpDIB)) 
	{ 
		DWORD dwClrUsed; 
		dwClrUsed = ((LPBITMAPINFOHEADER)lpDIB)->biClrUsed; 
		if (IS_WIN30_DIB(lpDIB)) 
		{ 
			DWORD dwClrUsed; 
			dwClrUsed = ((LPBITMAPINFOHEADER)lpDIB)->biClrUsed; 
			if (dwClrUsed) 
			{ 
				AfxMessageBox("由BITMAOINFOHEADER导出"); 
				return (WORD)dwClrUsed; 
			} 
		} 
 
		if (IS_WIN30_DIB(lpDIB)) 
		{ 
			wBitCount = ((LPBITMAPINFOHEADER)lpDIB)->biBitCount; 
			CString str; 
			str.Format("%d",wBitCount); 
 
		} 
		else 
		{ 
			wBitCount = ((LPBITMAPCOREHEADER)lpDIB)->bcBitCount; 
		} 
 
		switch (wBitCount) 
		{ 
		case 1: 
			return 2; 
		case 4: 
			return 16; 
		case 8: 
			return 256; 
		default: 
			return 0; 
		} 
	} 
	return 0; 
} 
 
 
BOOL CDib::PaintDIB(HDC hDC, LPRECT lpDCRect, LPRECT lpDIBRect) 
{ 
	LPSTR    lpDIBHdr;            
	LPSTR    lpDIBBits;           
	HPALETTE hPal; 
	BOOL     bSuccess  =FALSE;       
	HPALETTE hOldPal = NULL;        
 
	if (m_hDib == NULL) 
		return FALSE; 
 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
 
 
	if (m_pPalette != NULL) 
	{ 
		hPal = (HPALETTE) m_pPalette->m_hObject; 
		hOldPal = ::SelectPalette(hDC, hPal, TRUE); 
	} 
	::SetStretchBltMode(hDC, COLORONCOLOR); 
 
 
	if ((RECTWIDTH(lpDCRect)  == RECTWIDTH(lpDIBRect)) && 
	   (RECTHEIGHT(lpDCRect) == RECTHEIGHT(lpDIBRect))) 
		bSuccess = ::SetDIBitsToDevice(hDC,                     
								   lpDCRect->left,              
								   lpDCRect->top,               
								   RECTWIDTH(lpDCRect),         
								   RECTHEIGHT(lpDCRect),        
								   lpDIBRect->left,             
								   (int)DIBHeight(lpDIBHdr) - 
									  lpDIBRect->top - 
									  RECTHEIGHT(lpDIBRect),    
								   0,                           
								   (WORD)DIBHeight(lpDIBHdr),   
								   lpDIBBits,                   
								   (LPBITMAPINFO)lpDIBHdr,      
								   DIB_RGB_COLORS);             
   else 
	  bSuccess = ::StretchDIBits(hDC,                           
							   lpDCRect->left,                  
							   lpDCRect->top,                   
							   RECTWIDTH(lpDCRect),             
							   RECTHEIGHT(lpDCRect),            
							   lpDIBRect->left,                 
							   lpDIBRect->top,                  
							   RECTWIDTH(lpDIBRect),            
							   RECTHEIGHT(lpDIBRect),           
							   lpDIBBits,                       
							   (LPBITMAPINFO)lpDIBHdr,          
							   DIB_RGB_COLORS,                  
							   SRCCOPY);                        
 
   GlobalUnlock(m_hDib); 
 
 
	if (hOldPal != NULL) 
	{ 
		::SelectPalette(hDC, hOldPal, TRUE); 
	} 
 
   return bSuccess; 
} 
 
 
LPSTR CDib::FindDIBBits(LPSTR lpbi) 
{ 
	return (lpbi + *(LPDWORD)lpbi + PaletteSize(lpbi)); 
} 
 
WORD CDib::PaletteSize(LPSTR lpbi) 
{ 
 
   if (IS_WIN30_DIB (lpbi)) 
	  return (WORD)(DIBNumColors(lpbi) * sizeof(RGBQUAD)); 
   else 
	  return (WORD)(DIBNumColors(lpbi) * sizeof(RGBTRIPLE)); 
} 
 
HDIB CDib::Detach() 
{ 
	if (m_hDib == NULL) 
		return NULL; 
 
	HDIB hDib = m_hDib; 
	m_hDib = NULL; 
	 
	if ( m_pPalette != NULL) 
	{ 
		delete m_pPalette; 
		m_pPalette = NULL; 
	} 
	return m_hDib; 
} 
 
void CDib::Delay() 
{ 
	Sleep(25); 
} 
 
void CDib::Scan(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
	LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
 
	CBrush brush(RGB(244,196,242)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
	pDC->Rectangle(nLeft,nTop,nLeft+nWidth,nTop+nHeight); 
 
	int nScanWidth=25; 
 
	int nStart=0; 
	int nEnd=25; 
	for(nEnd=25; nEnd < nHeight + 25; nEnd = nEnd+25) 
	{ 
		int temp1 = GetHeight(); 
		int dibWidth = int(25 * temp1/nHeight); 
		int dibEnd = int(nEnd * temp1/nHeight); 
		int dibStart = int(nStart * temp1/nHeight); 
 
		StretchDIBits(pDC->GetSafeHdc(), 
					nLeft, nStart+nTop, 
					nWidth, 25, 
					0,temp1 - dibEnd, 
					GetWidth(),dibWidth, 
					lpDIBBits, lpBMI, 
					DIB_RGB_COLORS,SRCCOPY); 
		nStart = nEnd; 
		Delay(); 
		Delay(); 
		Delay(); 
	} 
	oldBrush=pDC->SelectObject(&brush); 
	oldPen=pDC->SelectObject(&pen); 
	pDC->SelectObject(oldBrush); 
	pDC->SelectObject(oldPen); 
} 
 
void CDib::MoveDown(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
		LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
	//创建画刷和画笔，用于清除 
	CBrush brush(RGB(244,196,242)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
	//恢复背景 
	pDC->Rectangle(nLeft,nTop,nWidth+nLeft,nHeight+nTop); 
	 
	//向下平移 
	for(int i=0;i < nHeight + 15;i=i+15) 
	{ 
		int temp1=GetHeight(); 
		int temp=int(i*temp1/nHeight); 
		StretchDIBits(pDC->GetSafeHdc(), 
					nLeft, nTop, 
					nWidth, i, 
					0,0, 
					GetWidth(),temp, 
					lpDIBBits, lpBMI, 
					DIB_RGB_COLORS,SRCCOPY); 
		Delay(); 
	} 
	pDC->SelectObject(oldBrush); 
	pDC->SelectObject(oldPen); 
} 
void CDib::MoveUp(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
	LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
	//创建画刷和画笔，用于清除 
	CBrush brush(RGB(244,196,242)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
	//恢复背景 
	pDC->Rectangle(nLeft,nTop,nWidth+nLeft,nHeight+nTop); 
	 
	for(int i=0;iGetSafeHdc(), 
					nLeft, nTop+nHeight-i, 
					nWidth, i, 
					0,GetHeight()-temp, 
					GetWidth(),temp, 
					lpDIBBits, lpBMI, 
					DIB_RGB_COLORS,SRCCOPY); 
		Delay();	 
	} 
	pDC->SelectObject(oldBrush); 
	pDC->SelectObject(oldPen); 
} 
 
void CDib::Masic(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
	LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
	CBrush brush(RGB(244,196,242)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
	pDC->Rectangle(nLeft,nTop,nWidth+nLeft,nHeight+nTop); 
	Delay(); 
 
	pDC->SetStretchBltMode(COLORONCOLOR); 
	int nDividedSize=25; 
	int nWidthAppend=0; 
	int nHeightAppend=0; 
 
	if((nWidth%nDividedSize)!=0) 
		nWidthAppend=1; 
	if((nHeight%nDividedSize)!=0) 
		nHeightAppend=1; 
	long lDividedNum=(nWidth/nDividedSize+nWidthAppend)*(nHeight/nDividedSize+nHeightAppend); 
 
	POINT *point=new POINT[lDividedNum]; 
	long mx=0;  
	long my=0;  
	int w=GetWidth(); 
	int h=GetHeight(); 
	double wScale=(double)w/(double)nWidth; 
	double hScale=(double)h/(double)nHeight; 
	for(long mi=0;minWidth) 
		{ 
			mx=0; 
			my=my+nDividedSize; 
		} 
	} 
 
	double fmax=RAND_MAX; 
	for(mi=lDividedNum-1;mi>=0;mi--) 
	{ 
		int randNum=rand(); 
		int n=(int)((double)randNum*(double)lDividedNum/fmax); 
		mx=point[n].x; 
		my=point[n].y; 
		StretchDIBits(pDC->GetSafeHdc(), 
						mx+nLeft, my+nTop, nDividedSize, nDividedSize, 
						(int)(mx*wScale), (int)((nHeight-my-nDividedSize)*hScale), (int)(nDividedSize*wScale), (int)(nDividedSize*hScale), 
						lpDIBBits, lpBMI, 
						DIB_RGB_COLORS,SRCCOPY); 
		Delay(); 
		point[n].x=-1; 
		point[n].y=-1; 
	} 
	for(mi=lDividedNum-1;mi>=0;mi--) 
	{ 
		if(point[mi].x!=-1&&point[mi].y!=-1) 
		{ 
			mx=point[mi].x; 
			my=point[mi].y; 
			StretchDIBits(pDC->GetSafeHdc(), 
						mx+nLeft, my+nTop, nDividedSize, nDividedSize, 
						(int)(mx*wScale), (int)((nHeight-my-nDividedSize)*hScale), (int)(nDividedSize*wScale), (int)(nDividedSize*hScale), 
						lpDIBBits, lpBMI, 
						DIB_RGB_COLORS,SRCCOPY);		 
		} 
	} 
	delete []point; 
} 
 
void CDib::Grid(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
		LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
	CBrush brush(RGB(244,196,242)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
 
	pDC->Rectangle(nLeft,nTop,nWidth+nLeft,nTop+nHeight); 
 
	int nScanLine=nWidth/20; 
	int w=GetWidth(); 
	int h=GetHeight(); 
 
	for(int i=0;iGetSafeHdc(), 
						j, nTop, nScanLine, (i+1), 
						j-nLeft, 0, (int)(nScanLine), (int)(i+1), 
						lpDIBBits, lpBMI, 
						DIB_RGB_COLORS,SRCCOPY); 
			 
			int k=j+nScanLine; 
			StretchDIBits(pDC->GetSafeHdc(), 
						k, nTop+nHeight-i, nScanLine, i, 
						k-nLeft,nHeight-i, nScanLine,i, 
						lpDIBBits,lpBMI, 
						DIB_RGB_COLORS,SRCCOPY); 
		} 
		Delay(); 
	} 
 
	pDC->SelectObject(oldBrush); 
	pDC->SelectObject(oldPen);	 
} 
 
void CDib::Window(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{//垂直百叶窗 
		LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
 
	CBrush brush(RGB(244,196,242)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
 
	pDC->Rectangle(nLeft,nTop,nWidth+nLeft,nTop+nHeight); 
 
	int nScanLine=15; 
 
	for(int i=0;iGetSafeHdc(), 
						j,nTop, 
						1,nHeight, 
						j-nLeft,0, 
						1,GetHeight(), 
						lpDIBBits, lpBMI, 
						DIB_RGB_COLORS,SRCCOPY); 
		} 
		Delay(); 
		Delay(); 
	} 
	pDC->SelectObject(oldBrush); 
	pDC->SelectObject(oldPen);	 
} 
 
void CDib::WindowLine(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
		LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
 
	CBrush brush(RGB(244,196,242)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
 
	pDC->Rectangle(nLeft,nTop,nLeft+nWidth,nHeight+nTop); 
 
	int nScanLine=15; 
 
	for(int i=0;iGetSafeHdc(), 
						nLeft,j, 
						nWidth,1, 
						0,nHeight-(j-nTop), 
						GetWidth(),1, 
						lpDIBBits, lpBMI, 
						DIB_RGB_COLORS,SRCCOPY); 
		} 
		Delay(); 
		Delay(); 
	} 
	pDC->SelectObject(oldBrush); 
	pDC->SelectObject(oldPen); 
} 
 
void CDib::ZoomPicture(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
	LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
 
	StretchDIBits(pDC->GetSafeHdc(), 
				nLeft,nTop, 
				nWidth,nHeight, 
				0,0, 
				GetWidth(),GetHeight(), 
				lpDIBBits, lpBMI, 
				DIB_RGB_COLORS,SRCCOPY); 
} 
 
DWORD CDib::BytesPerLine(HDIB hDIB) 
{ 
	LPSTR lpDIB = (LPSTR)GlobalLock(hDIB); 
	DWORD dw = WIDTHBYTES(((LPBITMAPINFOHEADER)lpDIB)->biWidth * ((LPBITMAPINFOHEADER)lpDIB)->biPlanes * ((LPBITMAPINFOHEADER)lpDIB)->biBitCount);  
	GlobalUnlock(hDIB); 
	return dw; 
} 
 
 
void CDib::Show(CDC *pDC, CRect rect, int type) 
{ 
	Zoom(rect.Width(),rect.Height()); 
	switch(type) 
	{ 
	case 1: 
		Grid(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 2: 
		Masic(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 3: 
		Scan(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 4: 
		MoveDown(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 5: 
		MoveUp(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 6: 
		Window(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 7: 
		WindowLine(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 8: 
		ZoomPicture(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	case 9: 
		ShutOff(pDC,rect.left,rect.top,rect.Width(),rect.Height()); 
		break; 
	} 
} 
 
 
HDIB CDib::ChangeDIBSize(HDIB hDIB, int nWidth, int nHeight) 
{ 
	LPBITMAPINFO lpbmi = NULL; 
	LPSTR		 lpSourceBits,lpTargetBits,lpResult; 
	HDC          hDC = NULL,hSourceDC,hTargetDC; 
	HBITMAP      hSourceBitmap,hTargetBitmap, 
				 hOldTargetBitmap,hOldSourceBitmap; 
	DWORD		 dwSourceBitsSize,dwTargetBitsSize,dwTargetHeaderSize; 
	HDIB		 hNewDIB; 
	DWORD        dwSize; 
 
	if (!hDIB) 
		return NULL; 
 
	LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDIB); 
	if (!lpSrcDIB) 
		return NULL; 
 
	dwTargetHeaderSize = sizeof(BITMAPINFOHEADER) + PaletteSize((LPSTR)lpSrcDIB); 
	lpbmi = (LPBITMAPINFO)malloc(dwTargetHeaderSize); 
	memcpy(lpbmi,lpSrcDIB,dwTargetHeaderSize); 
	lpbmi->bmiHeader.biWidth = nWidth; 
	lpbmi->bmiHeader.biHeight = nHeight; 
 
	hDC = GetDC(NULL); 
	hTargetBitmap = CreateDIBSection(hDC,lpbmi,DIB_RGB_COLORS,(VOID**)&lpTargetBits,NULL,0); 
	hSourceBitmap = CreateDIBSection(hDC,lpSrcDIB,DIB_RGB_COLORS,(VOID**)&lpSourceBits,NULL,0); 
	hSourceDC = CreateCompatibleDC(hDC); 
	hTargetDC = CreateCompatibleDC(hDC);  
 
	dwSourceBitsSize = lpSrcDIB->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpSrcDIB->bmiHeader)); 
	dwTargetBitsSize = lpbmi->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpbmi->bmiHeader)); 
	memcpy(lpSourceBits,FindDIBBits((LPSTR)lpSrcDIB),dwSourceBitsSize); 
 
	hOldSourceBitmap = (HBITMAP)SelectObject(hSourceDC,hSourceBitmap); 
	hOldTargetBitmap = (HBITMAP)SelectObject(hTargetDC,hTargetBitmap); 
 
	SetStretchBltMode(hTargetDC,COLORONCOLOR); 
	StretchBlt(hTargetDC,0,0, 
			   lpbmi->bmiHeader.biWidth,lpbmi->bmiHeader.biHeight, 
			   hSourceDC,0,0, 
			   lpSrcDIB->bmiHeader.biWidth,lpSrcDIB->bmiHeader.biHeight,SRCCOPY); 
 
	SelectObject(hSourceDC,hOldSourceBitmap); 
	SelectObject(hTargetDC,hOldTargetBitmap); 
	DeleteDC(hSourceDC); 
	DeleteDC(hTargetDC); 
	ReleaseDC(NULL,hDC); 
 
	GdiFlush(); 
 
	dwSize = dwTargetHeaderSize + dwTargetBitsSize; 
	hNewDIB = GlobalAlloc(GHND,dwSize); 
	lpResult = (LPSTR)GlobalLock(hNewDIB); 
	memcpy(lpResult,lpbmi,dwTargetHeaderSize); 
	memcpy(FindDIBBits((LPSTR)lpResult),lpTargetBits,dwTargetBitsSize); 
 
	::DeleteObject(hTargetBitmap); 
	::DeleteObject(hSourceBitmap); 
	free(lpbmi); 
	GlobalUnlock(hDIB); 
	GlobalUnlock(hDIB); 
	return hNewDIB; 
} 
 
BOOL CDib::Zoom(int nWidth,int nHeight) 
{ 
	HDIB hNewDib = ChangeDIBSize(m_hDib,nWidth,nHeight); 
	if ( !hNewDib) 
		return FALSE; 
	GlobalFree(m_hDib); 
	m_hDib = NULL; 
	m_hDib = hNewDib; 
	if ( !m_pPalette) 
		delete m_pPalette; 
	return TRUE; 
} 
 
BOOL CDib::Read() 
{ 
	if(m_Path!="") 
	{ 
		//CFile *m_File=new CFile(); 
		//CFileException fe; 
	//	if(m_File->Open(m_Path,CFile::modeRead)) 
	//	{	 
		if(	Read(m_Path)) 
			return TRUE; 
		//	m_File->Close(); 
		//	return TRUE; 
			 
	//	} 
		else 
			return FALSE; 
	} 
	else 
		return FALSE; 
	 
} 
 
void CDib::GetFronPicture() 
{ 
	if(m_Picture.GetSize()!=0) 
	{ 
		int max=m_Picture.GetSize(); 
		m_Index=(++m_Index)%max; 
		m_Path=m_Picture[m_Index].fileName; 
		Read(); 
	} 
	 
} 
 
void CDib::GetNextPicture() 
{ 
	if(m_Picture.GetSize()!=0) 
	{ 
		if(m_Index<=0) 
			m_Index=m_Index+m_Picture.GetSize(); 
		m_Path=m_Picture[--m_Index].fileName; 
		Read(); 
	} 
	 
	 
} 
 
void CDib::GetPicture() 
{ 
	m_Path=m_Picture[m_Index].fileName; 
	Read(); 
 
} 
 
void CDib::ShutOff(CDC *pDC, int nLeft, int nTop, int nWidth, int nHeight) 
{ 
	LPSTR    lpDIBHdr; 
	LPSTR    lpDIBBits;    
	LPBITMAPINFO lpBMI; 
	int upHaftLong=nHeight/2; 
	int downHaftLong=nHeight-upHaftLong; 
 
	if (m_hDib == NULL) 
		return; 
	lpDIBHdr  = (LPSTR) GlobalLock(m_hDib); 
	lpDIBBits = FindDIBBits(lpDIBHdr); 
	lpBMI = (LPBITMAPINFO)lpDIBHdr; 
 
	CBrush brush(RGB(0,0,255)); 
	CBrush* oldBrush=pDC->SelectObject(&brush); 
	CPen pen(PS_SOLID,1,RGB(0,0,255)); 
	CPen* oldPen=pDC->SelectObject(&pen); 
 
	pDC->Rectangle(nLeft,nTop,nWidth+nLeft,nHeight+nTop); 
	 
 
	for(int i=0;i <=downHaftLong;i=i+2) 
	{ 
		StretchDIBits(pDC->GetSafeHdc(), 
					nLeft, nTop, 
					nWidth, i, 
					0,upHaftLong, 
					GetWidth(),i, 
					lpDIBBits, lpBMI, 
					DIB_RGB_COLORS,SRCCOPY); 
 
		StretchDIBits(pDC->GetSafeHdc(), 
					nLeft, nTop+nHeight-i, 
					nWidth, i, 
					0,downHaftLong-i, 
					GetWidth(),i, 
					lpDIBBits, lpBMI, 
					DIB_RGB_COLORS,SRCCOPY); 
		Delay(); 
	} 
	pDC->SelectObject(oldBrush); 
	pDC->SelectObject(oldPen); 
 
} 
void CDib::ShowFrame(CDC* pDC,int x,int y,CRect rect,int styFrame) 
{ 
	COLORREF crOldBack=pDC->SetBkColor(RGB(255,255,255)); 
	COLORREF crOldText=pDC->SetTextColor(RGB(0,0,0)); 
	CDC dcImage,dcMask; 
	CBitmap bmp; 
	bmp.LoadBitmap(IDB_FRAME+styFrame); 
	BITMAP bm; 
	bmp.GetBitmap(&bm); 
	int nWidth=bm.bmWidth; 
	int nHeight=bm.bmHeight; 
	dcImage.CreateCompatibleDC(pDC); 
	dcMask.CreateCompatibleDC(pDC); 
	CBitmap* pOldBitmapImage=dcImage.SelectObject(&bmp); 
	CBitmap bitmapMask; 
	bitmapMask.CreateBitmap(nWidth,nHeight,1,1,NULL); 
	CBitmap* pOldBitmapMask=dcMask.SelectObject(&bitmapMask); 
	dcImage.SetBkColor(RGB(255,255,255)); 
	dcMask.StretchBlt(0,0,nWidth,nHeight,&dcImage,0,0,nWidth,nHeight,SRCCOPY); 
	pDC->StretchBlt(x,y,rect.Width(),rect.Height(),&dcImage,0,0,nWidth,nHeight,SRCINVERT); 
	pDC->StretchBlt(x,y,rect.Width(),rect.Height(),&dcMask,0,0,nWidth,nHeight,SRCAND); 
	pDC->StretchBlt(x,y,rect.Width(),rect.Height(),&dcImage,0,0,nWidth,nHeight,SRCINVERT); 
	dcImage.SelectObject(pOldBitmapImage); 
	dcMask.SelectObject(pOldBitmapMask); 
	pDC->SetBkColor(crOldBack); 
	pDC->SetTextColor(crOldText); 
} 
 
BOOL CDib::Read(LPCTSTR lpszPathName) 
{ 
	char drive[_MAX_DRIVE];    
	char dir[_MAX_DIR]; 
	char fname[_MAX_FNAME];    
	char ext[_MAX_EXT]; 
    LPCTSTR fileMid=lpszPathName; 
	_splitpath((LPCSTR)lpszPathName, drive, dir, fname, ext); 
	if (! stricmp(ext, ".jpg") || 
			 ! stricmp(ext, ".jpe") || 
			 ! stricmp(ext, ".jpeg")  
	   ) // JPEG file 
	{ 
	        CJpeg jpeg; 
		    if (! jpeg.Load(lpszPathName)) 
			return FALSE; 
 
		    HDIB hDIB = CopyHandle(jpeg.GetDib()->GetHandle()); 
		    if (hDIB == NULL) 
			    return FALSE; 
			CMidDib *MidDib=new CMidDib; 
		    MidDib->Attach(hDIB); 
 
	        CFile file(lpszPathName,CFile::modeRead); 
	        CString midStr=file.GetFilePath(); 
	        CString sMidFile=file.GetFileName(); 
	        int pathLenght=midStr.GetLength(); 
	        int fileLenght=sMidFile.GetLength(); 
            CString MidPath=midStr.Left(pathLenght-fileLenght);//光路径 
			CFile fWritePath(MidPath+"temp.bmp", CFile::modeNoTruncate|CFile::modeCreate|CFile::modeWrite); 
			MidDib->Write(&fWritePath); 
			fWritePath.Abort(); 
			CFile goalFile(MidPath+"temp.bmp",CFile::modeRead); 
            Read(&goalFile); 
			goalFile.Abort(); 
			goalFile.Remove(MidPath+"temp.bmp"); 
            delete MidDib; 
		    return TRUE; 
	} 
	CFile goalFile(lpszPathName,CFile::modeRead); 
    Read(&goalFile); 
    return TRUE; 
 
}