// Dib.cpp: implementation of the CDib class.
//
//////////////////////////////////////////////////////////////////////


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

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

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

	//	IMPLEMENT_DYNCREATE(CDib,CObject)
CDib::CDib()
{
	hdib=NULL;
	lps=NULL;
	dibwidth=0;
	dibheight=0;
	picturesize=0;

}
/////////////////////////////////////////////////////////////////////////////////////////

	
void CDib::LoadDIB(LPCTSTR lpfilename)
{
	HANDLE hfile;
	CString strs(lpfilename); 
	lps=lpfilename;  
	
	strc=strs;
	strc.Delete(strc.GetLength()-5);
	strc.Insert(strc.GetLength()-4,'c');
	//lpc=LPCTSTR(strc);


	strm=strs;
	strm.Delete(strm.GetLength()-5);
	strm.Insert(strm.GetLength()-4,'m');
	//lpm=LPCTSTR(strm);



	stry=strs;
	stry.Delete(stry.GetLength()-5);
	stry.Insert(stry.GetLength()-4,'y');
	//lpy=LPCTSTR(stry);



	strk=strs;
	strk.Delete(strk.GetLength()-5);
	strk.Insert(strk.GetLength()-4,'k');
	//lpk=LPCTSTR(strk);
		
	SetCursor(LoadCursor( NULL,IDC_WAIT ));  
		   
	if((hfile=CreateFile(lpfilename,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL))!=INVALID_HANDLE_VALUE)
	{
		hdib=ReadDIBFile(hfile);
		CloseHandle(hfile);
		SetCursor(LoadCursor(NULL,IDC_ARROW));
		return ;
	}
	else 
	{
		SetCursor(LoadCursor(NULL,IDC_ARROW));
		return ;
	}
}
	

//-------------------------------------------------------------------------


HANDLE CDib::ReadDIBFile(HANDLE hfile)
{
	BITMAPFILEHEADER bmfheader;
	DWORD dwbytesize;//size by byte;
    UINT ncolornum;
	HANDLE hdib;
	HANDLE hdibtmp;//used for globalrealloc()
	LPBITMAPINFOHEADER lpbi;
	DWORD offbits;
	DWORD dwread;

	dwbytesize=GetFileSize(hfile,NULL);
	
	// allocate memory for bitmapinfoheader and color table;
	hdib=GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)));
	if(!hdib)
		return NULL;
	lpbi=(LPBITMAPINFOHEADER)GlobalLock(hdib);
	if(!lpbi)
	{
		GlobalFree(hdib);
		return NULL;
	}
	
	// read the bitmapfileheader from our file;
	if(!ReadFile(hfile,(LPBYTE)&bmfheader,sizeof(BITMAPFILEHEADER),&dwread,NULL))
		goto ErrExit;
	if(sizeof(BITMAPFILEHEADER)!=dwread)
		goto ErrExit;

	if(bmfheader.bfType!='MB')      // is 'MB' not 'BM';
	{
		AfxMessageBox("it is not dib",MB_OK,0);
		goto ErrExit;
	}
	
	// read the bitmapinfoheader from our file;
	if(!ReadFile(hfile,(LPBYTE)lpbi,sizeof(BITMAPINFOHEADER),&dwread,NULL))
		goto ErrExit;
	if(sizeof(BITMAPINFOHEADER)!=dwread)
		goto ErrExit;

	// check is windows DIB or os/2 DIB;
	if(lpbi->biSize==sizeof(BITMAPCOREHEADER))
		goto ErrExit;

	
	// determine the size of the color table and read it.
	if(!(ncolornum=(UINT)lpbi->biClrUsed))																												
	{	if(lpbi->biBitCount!=24)
			ncolornum=1<<lpbi->biBitCount;
	}
	// fill in some default values if they is zero;
	if(lpbi->biClrUsed==0)			//else biClrUsed is actually color number used;
		lpbi->biClrUsed=ncolornum;   

	if(lpbi->biSizeImage==0)
		lpbi->biSizeImage=((((lpbi->biWidth*(DWORD)lpbi->biBitCount+31)&~31)>>3)*lpbi->biHeight);
	

		// get a proper-sized buffer for header, color table and bits;
		GlobalUnlock(hdib);

	    hdibtmp=GlobalReAlloc(hdib,lpbi->biSize+ncolornum*sizeof(RGBQUAD)+lpbi->biSizeImage,
			            GMEM_MOVEABLE);   
		if(!hdibtmp)					
			goto ErrExitNoUnlock;
		
		else
			hdib=hdibtmp;

		lpbi=(LPBITMAPINFOHEADER)GlobalLock(hdib);
        
		
		
		// read color table;
		ReadFile(hfile,(LPBYTE)(lpbi)+lpbi->biSize,ncolornum*sizeof(RGBQUAD),&dwread,NULL);

		offbits=lpbi->biSize+ncolornum*sizeof(RGBQUAD);
		if(bmfheader.bfOffBits!=0L)
			SetFilePointer(hfile,bmfheader.bfOffBits,NULL,FILE_BEGIN);

		   if(ReadFile(hfile,(LPBYTE)lpbi+offbits,lpbi->biSizeImage,&dwread,NULL))
			goto OkExit;


ErrExit:
			GlobalUnlock(hdib);
ErrExitNoUnlock:
			GlobalFree(hdib);
			return NULL;
OkExit:
			GlobalUnlock(hdib);
			return	hdib;
}


//----------------------------------------------------------------

        // pointer to dib :bitmapinfoheader,color table, bit data;
HPALETTE CDib::CreateDIBPalette(LPBYTE lpbi)
{
	LPLOGPALETTE lppal;
	HANDLE hlogpal;
	HPALETTE hpal=NULL;
	LPBITMAPINFO lpbmi;
	LPBITMAPCOREINFO lpbmc;
	BOOL bwinstyledib;//is win3.0 dib;
	int i,wcolornum;


	if(!lpbi)
		return NULL;

	//get pointer to bitmapinfo(win 3.0)
	lpbmi=(LPBITMAPINFO)lpbi;


    //get point to bitmapcoreinfo(os/2);
	lpbmc=(LPBITMAPCOREINFO)lpbi;

    //get the colornumber in the DIB;
	wcolornum=DIBNumColors(lpbi);

   // whether this is a win 3.0 DIB;
   bwinstyledib=IS_WIN30_DIB(lpbi);

   if(wcolornum)
   {
	hlogpal=GlobalAlloc(GHND,sizeof(LOGPALETTE)+sizeof(PALETTEENTRY)*wcolornum);
	if(!hlogpal)
		return NULL;
	lppal=(LPLOGPALETTE)GlobalLock(hlogpal);

	lppal->palVersion=0x300;
	lppal->palNumEntries=wcolornum;

	for(i=0;i<wcolornum;i++)
	{
		if(bwinstyledib)
		{
			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;
		}
		else
		{

			lppal->palPalEntry[i].peRed=lpbmc->bmciColors[i].rgbtRed;
			lppal->palPalEntry[i].peGreen=lpbmc->bmciColors[i].rgbtGreen;
			lppal->palPalEntry[i].peBlue=lpbmc->bmciColors[i].rgbtBlue;
			lppal->palPalEntry[i].peFlags=0;
		}
	}

		//create the palette and get handle to it;
		hpal=CreatePalette(lppal);

		if(!hpal)
		{
			GlobalUnlock(hlogpal);
			GlobalFree(hlogpal);
			return NULL;
		}

		// free memory block;
		GlobalUnlock(hlogpal);
		GlobalFree(hlogpal);
   }
   // return dib's palette
		return hpal;
}

//----------------------------------------------------------------
 // get color number from the dib's color table
  // lpdib: pointer to packed-dib memory block

WORD CDib::DIBNumColors(LPBYTE lpdib)
	{
		WORD wbitcount=((LPBITMAPINFOHEADER)lpdib)->biBitCount ;

		if(IS_WIN30_DIB(lpdib))
		{
			DWORD dwclrused;
			dwclrused=((LPBITMAPINFOHEADER)lpdib)->biClrUsed;
			if(dwclrused)
				return (WORD)dwclrused;
		     else 
				 return 1<<((LPBITMAPINFOHEADER)lpdib)->biBitCount;              //OR: (WORD)pow(2,((LPBITMAPINFOHEADER)lpdib)->biBitCount);
		}
		else
			return (WORD)pow(2,((LPBITMAPCOREHEADER)lpdib)->bcBitCount);
	}

  
//-----------------------------------------------------------------
   //    copy a rect of a dib to destinate rect; 	
	// hdib: bitmapinfo+imagebits

bool CDib::PaintDIB(HDC hdc, LPRECT lpdcrect,HPALETTE hpal)
{
	LPBYTE lpdibih;        // pointer to BITMAPINFOHEADER;
	LPBYTE lpdibits;       // pointer to DIB image bits;
//	LPBITMAPINFOHEADER lp;
	bool bsuccess;
	HPALETTE holdpal=NULL;

	if(!hdib)
		return NULL;

	lpdibih=(LPBYTE)GlobalLock(hdib);
	lpdibits=lpdibih+sizeof(BITMAPINFOHEADER)+DIBNumColors(lpdibih)*sizeof(RGBQUAD);
		
	// if not palette provided,create one from DIB;
	if(!hpal)
		hpal=CreateDIBPalette(lpdibih);

	if(hpal)
	{
		holdpal=SelectPalette(hdc,hpal,true);
		RealizePalette(hdc);
	}

	// make sure to use the stretching mode for color picture;
	SetStretchBltMode(hdc,COLORONCOLOR);

   if(StretchDIBits(hdc,lpdcrect->left,lpdcrect->top,RECTWIDTH(lpdcrect),RECTHEIGHT(lpdcrect),
	       0,0,((LPBITMAPINFOHEADER)lpdibih)->biWidth,((LPBITMAPINFOHEADER)lpdibih)->biHeight,
	        lpdibits,(LPBITMAPINFO)lpdibih,DIB_RGB_COLORS,SRCCOPY))
		bsuccess=true;


	GlobalUnlock(hdib);

	if(holdpal)
		SelectPalette(hdc,holdpal,false);
	GlobalUnlock(hdib);

	return bsuccess;
}



//--------------------------------------------------------------------------------------------------------