// Dib.cpp : implementation file
//

#include "stdafx.h"
#include "Dib.h"
#include "math.h"

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

#define pi 3.14159265

CDib::CDib()
{
	m_lWidth = 0;
	m_lHeight = 0;
	m_wBitCount = 0;
	m_nClrUsed = 0;
	m_dwSizeImage = 0;
	m_bIsLoadFile = false;

	m_lpBMPInfo = NULL;
	m_lpLogPal = NULL;
	m_lpImage = NULL;
	m_hdd = 0;
	m_hPal = 0;

}

CDib::~CDib()
{
	Empty();
}

CDib::CDib(LPCTSTR lpszPathName)
{
   	m_lWidth = 0;
	m_lHeight = 0;
	m_wBitCount = 0;
	m_nClrUsed = 0;
	m_dwSizeImage = 0;
	m_bIsLoadFile = false;

	m_lpBMPInfo = NULL;
	m_lpLogPal = NULL;
	m_lpImage = NULL;
	m_hdd = 0;
	m_hPal = 0;

	LoadBMP(lpszPathName);
}

BOOL CDib::LoadBMP(LPCTSTR lpszPathName)
{
   Empty();

   //open a file
   CFile file;
   if(!file.Open(lpszPathName,CFile::modeRead | 
	                                  CFile::shareDenyNone))
   {
	   AfxMessageBox("cann't open the file");
	   return false;
   }

   //read the header of the file
   LPBITMAPFILEHEADER lpBMPFileHeader = (LPBITMAPFILEHEADER)
	           new BYTE[sizeof(BITMAPFILEHEADER)];
   if(!lpBMPFileHeader)
   {
	   AfxMessageBox("not enough memory");
	   file.Close();
	   return false;
   }
   file.Read(lpBMPFileHeader,sizeof(BITMAPFILEHEADER));
   if(lpBMPFileHeader->bfType != 0x4d42)
   {
	   AfxMessageBox("It is not a BMP's file");
	   delete[] lpBMPFileHeader;
	   lpBMPFileHeader = NULL;
	   file.Close();
	   return false;
   }

   //read the structure of the BITMAPINFO 
   m_lpBMPInfo = (LPBITMAPINFO) new BYTE[lpBMPFileHeader->bfOffBits
	                          - sizeof(BITMAPFILEHEADER)];
   if(!m_lpBMPInfo)
   {
	   AfxMessageBox("not enough memory");
	   delete[] lpBMPFileHeader;
	   lpBMPFileHeader = NULL;
	   file.Close();
	   return false;
   }
   file.ReadHuge(m_lpBMPInfo,lpBMPFileHeader->bfOffBits
	                          - sizeof(BITMAPFILEHEADER) );
   m_lWidth = m_lpBMPInfo->bmiHeader.biWidth;
   m_lHeight = m_lpBMPInfo->bmiHeader.biHeight;
   m_wBitCount = m_lpBMPInfo->bmiHeader.biBitCount;
   m_nClrUsed = GetClrUsed();
   BytesPerLine=(m_lWidth * (m_wBitCount / 8) + 3)&~3;//m_lpBMPInfo->bmiHeader.biWidth*m_lpBMPInfo->bmiHeader.biPlanes
							//*m_lpBMPInfo->bmiHeader.biBitCount;
   
   if(m_nClrUsed<=16 && m_nClrUsed !=0)
   {
	   AfxMessageBox("The picture need more biBitCount");
	   delete[] lpBMPFileHeader;
	   lpBMPFileHeader = NULL;
	   delete[] m_lpBMPInfo;
	   m_lpBMPInfo = NULL;
	   file.Close();
	   return false;
   }
   //calculate the bytes of the picture
   m_dwSizeImage = ((m_lWidth * (m_wBitCount / 8) + 3)&~3)*m_lHeight;
   m_lpImage = new BYTE[m_dwSizeImage];
   if(!m_lpImage)
   {
	   AfxMessageBox("not enough memory");
	   delete[] lpBMPFileHeader;
	   lpBMPFileHeader = NULL;
	   delete[] m_lpBMPInfo;
	   m_lpBMPInfo = NULL;
	   file.Close();
	   return false;
   }
   file.ReadHuge(m_lpImage,m_dwSizeImage);

   //set the imformation of the palette;
   m_lpLogPal = (LPLOGPALETTE) new BYTE[sizeof(LPLOGPALETTE)
	                            +m_nClrUsed*sizeof(PALETTEENTRY)];
   m_lpLogPal->palVersion = 0x300;
   m_lpLogPal->palNumEntries = m_nClrUsed;
   for(int i = 0;i<m_nClrUsed;i++)
   {
	   m_lpLogPal->palPalEntry[i].peRed = m_lpBMPInfo->
		                                      bmiColors[i].rgbRed;
	   m_lpLogPal->palPalEntry[i].peBlue = m_lpBMPInfo->
		                                      bmiColors[i].rgbBlue;
	   m_lpLogPal->palPalEntry[i].peGreen = m_lpBMPInfo->
		                                      bmiColors[i].rgbGreen;
	   m_lpLogPal->palPalEntry[i].peFlags = 0;
   }
   m_hPal = ::CreatePalette(m_lpLogPal);
   delete[] lpBMPFileHeader;
   lpBMPFileHeader = NULL;
   file.Close();
   m_bIsLoadFile = true;
	
   return true;

}

void CDib::Empty()
{
	m_lWidth = 0;
	m_lHeight = 0;
	m_wBitCount = 0;
	m_nClrUsed = 0;
	m_dwSizeImage = 0;
	m_bIsLoadFile = false;

	if(m_lpBMPInfo)
		delete[] m_lpBMPInfo;
	m_lpBMPInfo = NULL;

	if(m_lpLogPal)
		delete[] m_lpLogPal;
    m_lpLogPal = NULL;

	if(m_lpImage)
		delete[] m_lpImage;
	m_lpImage = NULL;
//	if(m_lpImage1)
//		delete[] m_lpImage1;
//	m_lpImage1=NULL;

	if(m_hdd)
		::DrawDibClose(m_hdd);
	m_hdd = 0;

	if(m_hPal)
		::DeleteObject(m_hPal);
	m_hPal = 0;
}

DWORD CDib::GetClrUsed()
{
    if(m_lpBMPInfo->bmiHeader.biClrUsed == 0)
	{
		switch(m_wBitCount)
		{
		case 1:
			return 2;
		case 4:
			return 16;
		case 8:
			return 256;
		default:
			return 0;
		}
	}
	return m_lpBMPInfo->bmiHeader.biClrUsed;
}



BOOL CDib::Init(CDC *pDC)
{
	if(!m_bIsLoadFile)
		return false;
	m_hdd = ::DrawDibOpen();
	::DrawDibBegin(m_hdd,pDC->m_hDC,-1,-1,&m_lpBMPInfo->bmiHeader
		,m_lWidth,m_lHeight,DDF_ANIMATE);
	return true;

}

BOOL CDib::draw(CDC *pDC, CPoint originDes)
{
	CRect src;
	src.left = src.top = 0;
	src.right = m_lWidth;
	src.bottom = m_lHeight;
	::DrawDibDraw(m_hdd,pDC->m_hDC,originDes.x ,
				 originDes.y ,m_lWidth,-m_lHeight,&m_lpBMPInfo->bmiHeader,
				 (LPVOID)m_lpImage,src.left,src.top,m_lWidth,src.Height(),
				 DDF_SAME_HDC);
	return true;
}

/*
LONG CDib::GetPixOffset(LONG x, LONG y)
{
	return (m_lHeight-y-1)*BytesPerLine+x*m_wBitCount/8;
}



int CDib::ComputePixel(float x, float y, float &x1, float &y1)
{
	float r, nn;

  if (x==0 && y==0) 
  {
	 x1 = x;
	 y1 = y;
	 return 1;
  }

  nn = (float)sqrt(x*x + y*y);
  r = (float) (fabs(x) > fabs(y)) ? fabs(nn/x): fabs(nn/y);

  x1 = (r*x);
  y1 = (r*y);

  return 1;

}

void CDib::ComputerEllipseEffect(LPBYTE src,LPBYTE des)
{
   // CWaitCursor wait;
  int x, y, x1, y1,tmp1,tmp2;
  float fx, fy, xmid, ymid, ar;


  xmid = (float) (m_lWidth/2.0);
  ymid = (float) (m_lHeight/2.0);
  ar = (float)(m_lHeight)/(float)(m_lWidth);
  for (y=0; y<m_lHeight; y++)
  {
	 for (x=0; x<m_lWidth; x++)
	 {
		ComputePixel(ar*(x-xmid), y-ymid, fx, fy);
		x1 = (int)(xmid+fx/ar);
		y1 = (int)(ymid+fy);
	   if(x1>=0&&y1>=0&&x1<m_lWidth&&y1<m_lHeight)
		{
		tmp2=GetPixOffset(x1,y1);
		tmp1=GetPixOffset(x,y);
		des[tmp1] = src[tmp2];
		des[tmp1+1] = src[tmp2+1];
		des[tmp1+2] = src[tmp2+2];
		}
	 }
  }
  

}
*/