// AlphablendDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Alphablend.h"
#include "AlphablendDlg.h"
#include "alphablendfunc.h"

#include <mmsystem.h>

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

#define INTERVAL 20
#define ALPHA_STEP 0.02f

// Total time taken for transition : INTERVAL * ALPHA_STEP 

using namespace Gdiplus;


/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAlphablendDlg dialog

CAlphablendDlg::CAlphablendDlg(CWnd* pParent /*=NULL*/)
	:
//	m_Bmp1( L"E:\\NiceScenery2.jpg", FALSE ),
//	m_Bmp2( L"E:\\Zavikon Island2.jpg", FALSE ),
	m_pTempBmp( NULL ),
	m_pPixels1( NULL ), 
	m_pPixels2( NULL ), 
	CDialog(CAlphablendDlg::IDD, pParent)
	, m_nOptions(0)
	{
	//{{AFX_DATA_INIT(CAlphablendDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}


CAlphablendDlg::~CAlphablendDlg()
{
	if( m_pTempBmp )
	{
		delete [] m_pTempBmp;
		m_pTempBmp = NULL;
	}

	if( m_pPixels1 )
	{
		delete [] m_pPixels1;
		m_pPixels1 = NULL;
	}

	if( m_pPixels2 )
	{
		delete [] m_pPixels2;
		m_pPixels2 = NULL;
	}

}


void CAlphablendDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAlphablendDlg)
	DDX_Control(pDX, IDC_CHK_GRAPHICS, m_btnGraphics);
	DDX_Control(pDX, IDC_BTN_BENCHMARK, m_btnBenchmark);
	//}}AFX_DATA_MAP
	DDX_Control(pDX, IDC_RDO_UNOP, m_btnUnoptimized);
	DDX_Control(pDX, IDC_RDO_OP, m_btnOptimized);
	DDX_Control(pDX, IDC_RDO_VERYOP, m_btnVeryOptimized);
}

BEGIN_MESSAGE_MAP(CAlphablendDlg, CDialog)
	//{{AFX_MSG_MAP(CAlphablendDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_BTN_BENCHMARK, OnBtnBenchmark)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAlphablendDlg message handlers

BOOL CAlphablendDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	Gdiplus::Bitmap* pBmp1;
	Gdiplus::Bitmap* pBmp2;
	GetImage(&pBmp1,IDR_NICESCENERY);
	GetImage(&pBmp2,IDR_ISLAND);

	::ZeroMemory( &m_BmpData1, sizeof(m_BmpData1) );
	::ZeroMemory( &m_BmpData2, sizeof(m_BmpData2) );

	Rect rect1(0, 0, pBmp1->GetWidth(), pBmp1->GetHeight());

	m_pTempBmp = pBmp1->Clone( rect1, PixelFormat32bppARGB );
	//	ASSERT( m_pTempBmp );

	// First Bitmap
	pBmp1->LockBits( 
		&rect1, 
		ImageLockModeRead,
		PixelFormat32bppARGB,
		&m_BmpData1 );

	m_Stride1 = m_BmpData1.Stride;
	if( m_Stride1 < 0 )
		m_Stride1 = -m_Stride1;

	m_pPixels1 = new UINT[m_Stride1/4 * m_BmpData1.Height];
	ASSERT( m_pPixels1 );

	::CopyMemory( m_pPixels1, m_BmpData1.Scan0, m_Stride1 * m_BmpData1.Height );

	pBmp1->UnlockBits( 
		&m_BmpData1 );

	// Second Bitmap
	Rect rect2(0, 0, pBmp2->GetWidth(), pBmp2->GetHeight());

	pBmp2->LockBits( 
		&rect2, 
		ImageLockModeRead,
		PixelFormat32bppARGB,
		&m_BmpData2 );

	m_Stride2 = m_BmpData2.Stride;
	if( m_Stride2 < 0 )
		m_Stride2 = -m_Stride2;

	m_pPixels2 = new UINT[m_Stride2/4 * m_BmpData2.Height];
	ASSERT( m_pPixels2 );

	::CopyMemory( m_pPixels2, m_BmpData2.Scan0, m_Stride2 * m_BmpData2.Height );

	pBmp2->UnlockBits( 
		&m_BmpData2 );

	if(pBmp1)
	{
		delete pBmp1;
		pBmp1 = NULL;
	}

	if(pBmp2)
	{
		delete pBmp2;
		pBmp2 = NULL;
	}

	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CAlphablendDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CAlphablendDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
		//if(m_pTempBmp)
		//{
		//	CPaintDC dc(this); // device context for painting
		//	Gdiplus::Graphics graphics(dc.GetSafeHdc());
		//	graphics.DrawImage(m_pTempBmp, 0, 0);
		//}
		//else
		//	CDialog::OnPaint();

	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CAlphablendDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CAlphablendDlg::OnDestroy() 
{
	CDialog::OnDestroy();
}

void CAlphablendDlg::OnBtnBenchmark() 
{
	//UpdateData(FALSE);
	if(m_btnUnoptimized.GetCheck())
	{
		//MessageBox("Unoptimized");
		OnBenchmarkUnoptimized();
	}
	else if(m_btnOptimized.GetCheck())
	{
		//MessageBox("Optimized");
		OnBenchmarkOptimized();
	}
	else if(m_btnVeryOptimized.GetCheck())
	{
		//MessageBox("Very Optimized");
		OnBenchmarkVeryOptimized();
	}
	else
	{
		MessageBox("Options not selected");
	}

}

bool CAlphablendDlg::GetImage(Gdiplus::Bitmap** ppImage, int nResID)
{
	HINSTANCE hResInstance = AfxGetResourceHandle( );

	HRSRC res = FindResource(hResInstance,
		MAKEINTRESOURCE(nResID),"BINARY");
	if (res) 
	{
		HGLOBAL mem = LoadResource(hResInstance, res);
		void *data = LockResource(mem);
		size_t len = SizeofResource(hResInstance, res);

		HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, len);
		LPVOID pvData = GlobalLock( hGlobal );
		memcpy(pvData,data,len);
		GlobalUnlock(hGlobal);

		LPSTREAM pStream = NULL;
		HRESULT hr = CreateStreamOnHGlobal( hGlobal, TRUE, &pStream );

		using namespace Gdiplus;
		*ppImage = Bitmap::FromStream(pStream,true);

		pStream->Release();

		return true;
	}
	return false;
}

void CAlphablendDlg::OnBenchmarkUnoptimized() 
{
	bool bGraphics = m_btnGraphics.GetCheck() ? true : false; 

	m_btnGraphics.EnableWindow( FALSE );
	m_btnBenchmark.EnableWindow( FALSE );
	CWaitCursor wait;

	TIMECAPS resolution;
	DWORD start=0, finish=0, duration=0;//, maxtime=0;
	const int loop=1000;// loop change the number of looping here


	if (timeGetDevCaps (&resolution, sizeof (TIMECAPS)) == TIMERR_NOERROR)
	{
		TRACE ("Minimum supported resolution = %d\n", resolution.wPeriodMin);
		TRACE ("Maximum supported resolution = %d\n", resolution.wPeriodMax);
	}


	if (resolution.wPeriodMin <= 1)
	{
		if (timeBeginPeriod (1) == TIMERR_NOERROR)
		{
			start = timeGetTime ();

			const float step = ALPHA_STEP;
			float fCnt = -ALPHA_STEP;
			float Toggle = step;

			for( int i=0; i<loop; ++i )
			{
				if( m_pTempBmp )
				{
					fCnt += Toggle;


					if( fCnt > 1.0f )
					{
						fCnt = 1.0f;
						Toggle = -step;
					}
					else if( fCnt < 0.0f )
					{
						fCnt = 0.0f;
						Toggle = step;
					}


					BYTE Alpha = 0;

					Alpha = BYTE( 255 * fCnt );

					CClientDC dc(this);
					Graphics graphics( dc.GetSafeHdc() );

					UINT* pixels = NULL;

					// Lock a 50