// ex29View.cpp : implementation of the CEx29View class
//

#include "stdafx.h"
#include "ex29.h"

#include "ex29Doc.h"
#include "ex29View.h"

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

/////////////////////////////////////////////////////////////////////////////
// CEx29View
CEx29View *pView;

UINT ThreadSortBubble(LPVOID lp)
{
	int * data;
	int i,j,k;
	int tag;
	data=pView->m_SortBubble;
	for(i=0;i<N;i++)
	{
		tag=0;
		for(j=N-1;j>i;j--)
		{
			if(data[j]>data[j-1])
			{
				k=data[j];
				data[j]=data[j-1];
				data[j-1]=k;
				Sleep(DELAY);
				pView->Invalidate(TRUE);
				tag++;
			}
		}
		if(tag==0)
			break;
	}
	pView->Invalidate(TRUE);
	return 0;
}

void QuickSort(int * data,int low,int high)
{
	int i=low,j=high;
	int tmp,k;

	if(low<high)
	{
		tmp=data[low];
		while(i<j)
		{
			while(i<j&&data[j]<=tmp) j--;
			k=data[i];
			data[i]=data[j];
			data[j]=k;
			Sleep(DELAY);
			pView->Invalidate(TRUE);

			while(i<j&&data[i]>=tmp) i++;
			k=data[i];
			data[i]=data[j];
			data[j]=k;
			Sleep(DELAY);
			pView->Invalidate(TRUE);
		}
		QuickSort(data,low,i-1);
		QuickSort(data,i+1,high);
	}
}

UINT ThreadSortQuick(LPVOID lp)
{
	int * data;
	data=pView->m_SortQuick;
	pView->Invalidate(TRUE);
	Sleep(DELAY);
	QuickSort(data,0,N-1);

	return 0;
}

UINT ThreadSortSelect(LPVOID lp)
{
	int i,j,k,tmp;
	int *data;
	data=pView->m_SortSelect;

	for(i=0;i<N-1;i++)
	{
		k=i;
		for(j=i+1;j<N;j++)
		{
			if(data[j]>data[k]) 
			{
				k=j;
				Sleep(DELAY);
				pView->Invalidate(TRUE);
			}
		}
		tmp=data[i];
		data[i]=data[k];
		data[k]=tmp;
	}
	
	Sleep(DELAY);
	pView->Invalidate(TRUE);
	return 0;
}

IMPLEMENT_DYNCREATE(CEx29View, CView)

BEGIN_MESSAGE_MAP(CEx29View, CView)
	//{{AFX_MSG_MAP(CEx29View)
	ON_COMMAND(ID_SORT_BUBBLE, OnSortBubble)
	ON_COMMAND(ID_SORT_QUICK, OnSortQuick)
	ON_COMMAND(ID_SORT_SELECT, OnSortSelect)
	ON_COMMAND(ID_SORT_ALL, OnSortAll)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CEx29View construction/destruction

CEx29View::CEx29View()
{
	// TODO: add construction code here
	int i;
	srand((unsigned)time(NULL));
	for(i=0;i<N;i++)
		m_SortBubble[i]=m_SortQuick[i]=m_SortSelect[i]=0;
	pView=this;
	IsSortSelect=FALSE;
	IsSortQuick=FALSE;
	IsSortBubble=FALSE;
}

CEx29View::~CEx29View()
{
}

BOOL CEx29View::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CEx29View drawing

void CEx29View::OnDraw(CDC* pDC)
{
	int i;
	CEx29Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
	if(IsSortBubble)
	{
		CBrush BlueBrush(RGB(0,0,255));
		pDC->TextOut(100,200,"冒泡法排序演示");
		for(i=0;i<N;i++)
		{
			m_SortBubbleRect.bottom=170;
			m_SortBubbleRect.left=50+i*2;
			m_SortBubbleRect.right=m_SortBubbleRect.left+1;
			m_SortBubbleRect.top=m_SortBubbleRect.bottom-m_SortBubble[i];
			pDC->FillRect(&m_SortBubbleRect,&BlueBrush);
		}
		BlueBrush.DeleteObject();
	}
	if(IsSortQuick)
	{
		CBrush RedBrush(RGB(255,0,0));
		pDC->TextOut(320,200,"快速排序法演示");
		for(i=0;i<N;i++)
		{
			m_SortQuickRect.bottom=170;
			m_SortQuickRect.left=270+i*2;
			m_SortQuickRect.right=m_SortQuickRect.left+1;
			m_SortQuickRect.top=m_SortQuickRect.bottom-m_SortQuick[i];
			pDC->FillRect(&m_SortQuickRect,&RedBrush);
		}
		RedBrush.DeleteObject();
	}
	if(IsSortSelect)
	{
		CBrush GreenBrush(RGB(0,255,0));
		pDC->TextOut(540,200,"選擇排序法演示");
		for(i=0;i<N;i++)
		{
			m_SortSelectRect.bottom=170;
			m_SortSelectRect.left=490+i*2;
			m_SortSelectRect.right=m_SortSelectRect.left+1;
			m_SortSelectRect.top=m_SortSelectRect.bottom-m_SortSelect[i];
			pDC->FillRect(&m_SortSelectRect,&GreenBrush);
		}
		GreenBrush.DeleteObject();
	}
}

/////////////////////////////////////////////////////////////////////////////
// CEx29View printing

BOOL CEx29View::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CEx29View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CEx29View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CEx29View diagnostics

#ifdef _DEBUG
void CEx29View::AssertValid() const
{
	CView::AssertValid();
}

void CEx29View::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CEx29Doc* CEx29View::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CEx29Doc)));
	return (CEx29Doc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CEx29View message handlers

void CEx29View::OnSortBubble() 
{
	// TODO: Add your command handler code here
	int i;
	for(i=0;i<N;i++)
	{
		m_SortBubble[i]=(int)((double)rand()*100.0/(double)RAND_MAX);
	}

	IsSortBubble=TRUE;
	AfxBeginThread(ThreadSortBubble,GetSafeHwnd());
}

void CEx29View::OnSortQuick() 
{
	// TODO: Add your command handler code here
	int i;
	for(i=0;i<N;i++)
	{
		m_SortQuick[i]=(int)((double)rand()*100.0/(double)RAND_MAX);
	}
	
	IsSortQuick=TRUE;
	AfxBeginThread(ThreadSortQuick,GetSafeHwnd());
}

void CEx29View::OnSortSelect() 
{
	// TODO: Add your command handler code here
	int i;
	for(i=0;i<N;i++)
	{
		m_SortSelect[i]=(int)((double)rand()*100.0/(double)RAND_MAX);
	}
		
	IsSortSelect=TRUE;
	AfxBeginThread(ThreadSortSelect,GetSafeHwnd());
}

void CEx29View::OnSortAll() 
{
	// TODO: Add your command handler code here
	OnSortBubble();
	OnSortQuick();
	OnSortSelect();
}