Скачиваний:
15
Добавлен:
01.05.2014
Размер:
24.43 Кб
Скачать
// ConvexHullView.cpp : implementation of the CConvexHullView class
//

#include "stdafx.h"
#include "ConvexHull.h"

#include "ConvexHullDoc.h"
#include "ConvexHullView.h"

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

#include "StatusControl.h"
#include "StatusSlider.h"

#include "MainFrm.h"
#include "ChildFrm.h"
#include "GenerateDlg.h"
#include "TEdge.h"

extern CConvexHullApp theApp;


UINT WorkThread(LPVOID pParam);
UINT Stop(LPVOID pParam);
BOOL WriteWindowToDIB( LPCTSTR szFile, CRect	rect, CWnd *pWnd);

#define TIMER_DELAY 250

#define WM_THREADFINISHED	WM_USER	+ 10
#define ID_TIMER_1			100


/////////////////////////////////////////////////////////////////////////////
// CConvexHullView

IMPLEMENT_DYNCREATE(CConvexHullView, CView)

BEGIN_MESSAGE_MAP(CConvexHullView, CView)
	//{{AFX_MSG_MAP(CConvexHullView)
	ON_COMMAND(ID_BUTTONMOVEDOWN, OnButtonmovedown)
	ON_COMMAND(ID_BUTTONMOVELEFT, OnButtonmoveleft)
	ON_COMMAND(ID_BUTTONMOVERIGHT, OnButtonmoveright)
	ON_COMMAND(ID_BUTTONMOVEUP, OnButtonmoveup)
	ON_COMMAND(ID_BUTTONZOOMMINUS, OnButtonzoomminus)
	ON_COMMAND(ID_BUTTONZOOMPLUS, OnButtonzoomplus)
	ON_UPDATE_COMMAND_UI(ID_BUTTONZOOMPLUS, OnUpdateButtonzoomplus)
	ON_COMMAND(ID_BUTTONMOVECENTER, OnButtonmovecenter)
	ON_WM_MOUSEMOVE()
	ON_UPDATE_COMMAND_UI(ID_BUTTONMOVECENTER, OnUpdateButtonmovecenter)
	ON_COMMAND(ID_BUTTONZOOMNONE, OnButtonzoomnone)
	ON_UPDATE_COMMAND_UI(ID_BUTTONZOOMNONE, OnUpdateButtonzoomnone)
	ON_WM_SETCURSOR()
	ON_WM_MOUSEWHEEL()
	ON_WM_LBUTTONDOWN()
	ON_COMMAND(ID_GENERATE, OnGenerate)
	ON_COMMAND(ID_BUTTONPLAY, OnButtonplay)
	ON_COMMAND(ID_BUTTONSTEP, OnButtonstep)
	ON_COMMAND(ID_BUTTONSTOP, OnButtonstop)
	ON_COMMAND(ID_PLAY, OnPlay)
	ON_COMMAND(ID_RESTART, OnRestart)
	ON_COMMAND(ID_STEP, OnStep)
	ON_COMMAND(ID_SCREENSHOTS, OnScreenshots)
	ON_UPDATE_COMMAND_UI(ID_GENERATE, OnUpdateGenerate)
	ON_WM_RBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_TIMER()
	ON_UPDATE_COMMAND_UI(ID_BUTTONSTEP, OnUpdateButtonstep)
	ON_UPDATE_COMMAND_UI(ID_STEP, OnUpdateStep)
	ON_UPDATE_COMMAND_UI(ID_BUTTONPLAY, OnUpdateButtonplay)
	ON_UPDATE_COMMAND_UI(ID_PLAY, OnUpdatePlay)
	ON_COMMAND(ID_BUTTONBREAK, OnButtonbreak)
	ON_UPDATE_COMMAND_UI(ID_BUTTONBREAK, OnUpdateButtonbreak)
	ON_COMMAND(ID_BREAK, OnBreak)
	ON_UPDATE_COMMAND_UI(ID_BREAK, OnUpdateBreak)
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_NOTIFY(NM_CUSTOMDRAW, ID_INDICATOR_SLIDER, OnCustomdrawSlider1)
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
	ON_MESSAGE(WM_THREADFINISHED,OnThreadFinished)
	//ON_MESSAGE(WM_SLIDER_SEND, OnSliderChange)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CConvexHullView construction/destruction

CConvexHullView::CConvexHullView(): VIEW_X(0), VIEW_Y(0), SIZE(50), CUTTER(30), RESIZE(0), typePane(0), oldDelay(-1), Auto(false)
{

	cPen[0] = new CPen(PS_SOLID,1.5,16711935);
	cPen[1] = new CPen(PS_SOLID,1.5,32768);
	cPen[2] = new CPen(PS_SOLID,1.5,16711680);
	cPen[3] = new CPen(PS_SOLID,1.5,255);
	cPen[4] = new CPen(PS_SOLID,1.5,128);
	cPen[5] = new CPen(PS_SOLID,1.5,16776960);
	cPen[6] = new CPen(PS_SOLID,1.5,65535);
	cPen[7] = new CPen(PS_SOLID,1.5,65280);
	cPen[8] = new CPen(PS_SOLID,1,RGB(0,0,0));
	
	isClear = false;


	blFlagMove=FALSE;

	 
}

CConvexHullView::~CConvexHullView()
{
	//KillTimer(ID_TIMER_2);


	for (int i=0; i<9;i++){
		delete (cPen[i]);
	}
	

}

BOOL CConvexHullView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
/*	
	this->EnableToolTips(TRUE);
	
	toolTip.Create(this,TTS_ALWAYSTIP);
	toolTip.AddTool(this,"fsdfdsfdsfsdfsfs");
	toolTip.Activate(TRUE);
*/

	EnableToolTips(TRUE);   // enable tool tips for view

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CConvexHullView drawing


void CConvexHullView::DrawView1(CDC* pDC)
{
	
	CFont font;
	TEXTMETRIC tm;
	int point(16);

	font.CreateFont(point,0,0,0,400,FALSE,FALSE,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY, DEFAULT_PITCH|FF_SWISS, "Arial"); 
	pDC->SelectObject(&font); 
	pDC->GetTextMetrics(&tm); 
	

	
	int h,w;
	CRect rect;
	GetWindowRect( &rect );
	h=rect.Height(); w=rect.Width();  
	//pDC->TextOut(w/2 ,h/2 ,"View1");
	
	

	
	num_top = -(((w-CUTTER)/(SIZE))/2);
	num_left = (((h-CUTTER)/SIZE)/2);


#ifndef SIMPLIFICATION
	
	char top[5];
	char left[5];



	pDC->SelectObject(cPen[8]); 
	int count =0;
	for (int i=SIZE;i<w-CUTTER;){		
		itoa((num_top+count-VIEW_X)*(SIZE-RESIZE),top,10);
		pDC->TextOut(i-tm.tmAveCharWidth/2*strlen(top) ,CUTTER-tm.tmHeight,top); 
		pDC->MoveTo(i,0+CUTTER);  
		pDC->LineTo(i,h-CUTTER); 
		i+=SIZE;
		count++;
	}

	count = 0;
	for (int j=SIZE;j<h-CUTTER;){
		itoa((num_left-count+VIEW_Y)*(SIZE-RESIZE),left,10);
		pDC->TextOut(CUTTER-tm.tmAveCharWidth*strlen(left)-5 ,j-tm.tmHeight/2 ,left); 
		pDC->MoveTo(0+CUTTER,j);  
		pDC->LineTo(w-CUTTER,j); 
		j+=SIZE;
		count++;
	}




#endif




	/////////////////////////////////////////////////////

	if (blFlagMove) {
		pDC->Rectangle(CRect(start,end)); 
	}
	////////////////////////////////////////////////////









	//pDC->Ellipse(CRect(50,50,100,100));  
	CConvexHullDoc* pDoc = GetDocument();
	//TRACE("SCENE = %d\n", pDoc->Scene.size());
	for (unsigned t = 0; t < pDoc->Scene.size(); t++) {
		TGVector* tmp = pDoc->Scene[t];
		//TRACE("TMP = %d\n", tmp->size());
		pDC->SelectObject(cPen[t % 8]); 
		for (unsigned r = 0; r < tmp->size(); r++) {
			switch ( (*tmp)[r]->GetType() ){
			case G_EDGE:
				{
					TEdge* edge = (TEdge*)(*tmp)[r];
					DrawScnEdge(pDC, *edge);  
					//TRACE("EDGE\n");
					break;             
				}
			case G_POINT:
				{
					TPoint* scn_pnts = (TPoint*)(*tmp)[r];
					
					if (scn_pnts->used) pDC->SelectObject(cPen[5]);

					DrawScnPoint(pDC, *scn_pnts); 
					
					pDC->SelectObject(cPen[t % 8]);

					//TRACE("POINT\n");
					break;
				}
			case G_POLYGON:
				{
					TPolygon* scn_poly = (TPolygon*)(*tmp)[r];
					DrawScnPoly(pDC, scn_poly);  
					//TRACE("POLYGON\n");
					break;
				}


			}
		}
		
		
		//TRACE("%d", t);
	}
	//TRACE("\n");
	//TGVector* tmp = pDoc->Scene[i];

}


void CConvexHullView::DrawView2(CDC* pDC)
{
	pDC->TextOut(10,10,"Обозначения:");
	
	pDC->SetTextColor(16711680);
	pDC->TextOut(10,40,"Верхний мостик"); 
	pDC->SetTextColor(255);
	pDC->TextOut(10,60,"Нижний мостик"); 
	pDC->SetTextColor(32768);
	pDC->TextOut(10,80,"Полигон"); 
	pDC->SetTextColor(128);
	pDC->TextOut(10,100,"Результат"); 

}

void CConvexHullView::OnDraw(CDC* pDC){

	this->statusInfo(); 

	CConvexHullDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	
/*	
	CMainFrame* mf = (CMainFrame*)theApp.GetMainWnd();
	CChildFrame* child = (CChildFrame*)mf->GetActiveFrame(); 

	if (child->m_wndSplitter.GetColumnCount()==2){
		if (this == child->m_wndSplitter.GetPane(0,0) ){
			typePane=1;
			this->DrawView1(pDC); 
			
		}
		if (this == child->m_wndSplitter.GetPane(0,1) ){
			typePane=2;
			this->DrawView2(pDC);
		}
	}
	else{
		this->DrawView1(pDC); 
	}
*/
	switch (GetActivePane()){
		case 0 :{
			this->DrawView1(pDC);
			break;
		}
		case 1 :{
			this->DrawView1(pDC); 
			break;
		}
		case 2 :{
			this->DrawView2(pDC);
			break;
		}
	}
	 
}

/////////////////////////////////////////////////////////////////////////////
// CConvexHullView printing

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CConvexHullView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CConvexHullView message handlers

void CConvexHullView::OnButtonmovedown() 
{
	VIEW_Y--;
	this->RedrawWindow();  
}

void CConvexHullView::OnButtonmoveleft() 
{
	VIEW_X++;
	this->RedrawWindow(); 

}

void CConvexHullView::OnButtonmoveright() 
{
	VIEW_X--;
	this->RedrawWindow(); 

}

void CConvexHullView::OnButtonmoveup() 
{
	VIEW_Y++;
	this->RedrawWindow(); 
	
}

void CConvexHullView::OnButtonzoomminus() 
{
	RESIZE-=10;
	this->RedrawWindow(); 
}

void CConvexHullView::OnButtonzoomplus() 
{
	RESIZE+=10;
	
	this->RedrawWindow(); 
	
}

void CConvexHullView::OnUpdateButtonzoomplus(CCmdUI* pCmdUI) 
{
	if (SIZE-RESIZE==10) {
		pCmdUI->Enable(FALSE); 
	}	
}

void CConvexHullView::OnButtonmovecenter() {
	VIEW_Y=0;
	VIEW_X=0;
	this->RedrawWindow(); 
	
}



void CConvexHullView::OnUpdateButtonmovecenter(CCmdUI* pCmdUI) 
{
	if ((VIEW_Y==0)&&(VIEW_X==0)) {
		pCmdUI->Enable(FALSE); 
	}
}

void CConvexHullView::OnButtonzoomnone() 
{
	RESIZE=0;
	this->RedrawWindow(); 
}

void CConvexHullView::OnUpdateButtonzoomnone(CCmdUI* pCmdUI) 
{
	if (RESIZE==0){
		pCmdUI->Enable(FALSE); 
	}
	
}

BOOL CConvexHullView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	//return CView::OnSetCursor(pWnd, nHitTest, message);
	CConvexHullDoc* pDoc = GetDocument();

	if (pDoc->thread==NULL)
	switch(GetActivePane()){
	case 1:
	case 0: {
		::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS)); 
		break;
			}
	case 2:{
		::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW)); 
		break;
		   }
		
	}

	return TRUE;
}



int CConvexHullView::GetActivePane(){
	
	int result=0;

	CMainFrame* mf = (CMainFrame*)theApp.GetMainWnd();
	CChildFrame* child = (CChildFrame*)mf->GetActiveFrame(); 
	
	if (child->m_wndSplitter.GetColumnCount()==2){
		if (this == child->m_wndSplitter.GetPane(0,0) ){
			result=1;
		}
		if (this == child->m_wndSplitter.GetPane(0,1) ){
			result=2;
		}
	}
	
	return result;
}

BOOL CConvexHullView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt){
	
	if ((zDelta>0)&&!(SIZE-RESIZE==10)){
		RESIZE+=10;
		this->RedrawWindow(); 
	}
	if ((zDelta<0)){
		RESIZE-=10;
		this->RedrawWindow(); 
	}
	
	return CView::OnMouseWheel(nFlags, zDelta, pt);
}



void CConvexHullView::OnGenerate() {
	
	CConvexHullDoc* pDoc = GetDocument();
	
	CGenerateDlg dlg;
	dlg.SetGenValues(&pDoc->gen_info);
	
	if (dlg.DoModal() ==IDOK){
		pDoc->gen_info = dlg.GetGenValues();

		  int num_points = pDoc->gen_info.count; 
		  double x_left = pDoc->gen_info.min_x;
		  double x_right = pDoc->gen_info.max_x;
		  double y_top = pDoc->gen_info.max_y; 
		  double y_bottom = pDoc->gen_info.min_y;
		  
		  pDoc->Alg.Generate((pDoc->InputData[0]), pDoc->gen_info);
		
		this->RedrawWindow();
		pDoc->UpdateAllViews(this);
		
		pDoc->SetModifiedFlag();

	}

}

void CConvexHullView::DrawScnPoint(CDC *pDC, TPoint scn_pnt){

	TPoint pic_pnt = ConvScnToPic(CPoint(scn_pnt.x, scn_pnt.y));
	pDC->Ellipse(pic_pnt.x - 5, pic_pnt.y - 5,  pic_pnt.x + 5, pic_pnt.y + 5   ); 
}

TPicPoint CConvexHullView::ConvScnToPic(CPoint point){

	TPicPoint PicCoord; 
	PicCoord.x = point.x*SIZE/(SIZE-RESIZE) - (SIZE-RESIZE)*(num_top-1-VIEW_X)*SIZE/(SIZE-RESIZE);
	PicCoord.y = point.y*SIZE/(RESIZE-SIZE) - (SIZE-RESIZE)*(num_left+1+VIEW_Y)*SIZE/(RESIZE-SIZE);
	
	return PicCoord;
}

TScnPoint CConvexHullView::ConvPicToScn(CPoint point){

	TScnPoint RealCoord; 	
	
	RealCoord.x = (point.x+(SIZE)*(num_top-1-VIEW_X)-point.x*RESIZE/SIZE-RESIZE*(num_top-1-VIEW_X));
	RealCoord.y =  -(point.y-(num_left+1+VIEW_Y)*SIZE-point.y*RESIZE/SIZE+RESIZE*(num_left+1+VIEW_Y));

   return RealCoord;

}

void CConvexHullView::DrawScnPoly(CDC *pDC, TPolygon *poly){

  Vertex* vert = poly->v();
  if (vert != NULL) {
    TPoint pic_pnt = ConvScnToPic(CPoint(vert->x, vert->y));
    
    pDC->MoveTo(pic_pnt.x, pic_pnt.y);
    for (int i = 1; i <= poly->size(); i++) {
      vert = vert->cw();
      pic_pnt = ConvScnToPic(CPoint(vert->x, vert->y));
      
	  //pic_pnt.used  = TRUE;
	  

	  pDC->LineTo(pic_pnt.x, pic_pnt.y);
      pDC->Ellipse(pic_pnt.x - 5, pic_pnt.y - 5, pic_pnt.x + 5, pic_pnt.y + 5 ); 

      pDC->MoveTo(pic_pnt.x, pic_pnt.y);
              
    }
  }

}

void CConvexHullView::DrawScnEdge(CDC *pDC, TEdge edge){

   TPoint p1 = ConvScnToPic(CPoint(edge.Begin.x, edge.Begin.y));
   TPoint p2 = ConvScnToPic(CPoint(edge.End.x,  edge.End.y));
   pDC->MoveTo(p1.x, p1.y);
   pDC->LineTo(p2.x, p2.y);  
}

void CConvexHullView::OnButtonplay() 
{
	Auto = true;

	int i = GetDelay();
	oldDelay = i;
	
	if (i==0) {
		this->GetDocument()->Alg.setRunMode(AT_ONCE); 
		RunMode = AT_ONCE;
	}
	else{
		this->GetDocument()->Alg.setRunMode(BY_STEP); 
		RunMode = BY_STEP;
	}

	KillTimer(ID_TIMER_1); 
	::SetTimer(this->m_hWnd ,ID_TIMER_1,i*TIMER_DELAY,NULL);
	

	isClear = false;
	CConvexHullDoc* pDoc =GetDocument();

	TRACE("PLAY in View\n");
	
	if (pDoc->thread==NULL){
		TRACE("RUN THREAD\n");
		pDoc->ClearMem();
		this->RedrawWindow();
		pDoc->UpdateAllViews(this);
		//RunMode = AT_ONCE;
		//RunMode = BY_STEP;
		pDoc->Alg.SetView(this);  
		pDoc->thread = AfxBeginThread(WorkThread, this, ID_THREAD_PRIORITY);
		this->RedrawWindow(); 
		pDoc->UpdateAllViews(this);
	}
	else{
		//pDoc->Alg.setRunMode(AT_ONCE); 
		//pDoc->Alg.setRunMode(BY_STEP); 
	
		//pDoc->Alg.g_eventContinue.SetEvent();
	}
	
	
	
	
	
}

void CConvexHullView::OnButtonstep() 
{
	isClear = false;
	CConvexHullDoc* pDoc =GetDocument();

	if (pDoc->thread==NULL){
		TRACE("RUN THREAD\n");
		pDoc->ClearMem();
		pDoc->Alg.SetView(this);
		this->RedrawWindow();
		pDoc->UpdateAllViews(this);
		RunMode = BY_STEP;
		pDoc->thread = AfxBeginThread(WorkThread, this, ID_THREAD_PRIORITY);
		this->RedrawWindow(); 
		pDoc->UpdateAllViews(this);
	}
	else{
		pDoc->Alg.g_eventContinue.SetEvent();
		this->RedrawWindow(); 
		pDoc->UpdateAllViews(this);
	}
	
	
}

void CConvexHullView::OnButtonstop() 
{
	CConvexHullDoc* pDoc =GetDocument();
	isClear = true;
	pDoc->Alg.setRunMode(AT_ONCE); 
	pDoc->Alg.g_eventContinue.SetEvent();
	this->RedrawWindow();
	pDoc->UpdateAllViews(this);
	if (pDoc->thread) AfxBeginThread(Stop, this, ID_THREAD_PRIORITY);
	else {
		pDoc->ClearMem();
		this->RedrawWindow();
	}
}


UINT Stop(LPVOID pParam){
	TRACE("STOP\n");

	CConvexHullView* v = (CConvexHullView*)pParam;

	
	CConvexHullDoc* pDoc =v->GetDocument();

		pDoc->Alg.setRunMode(AT_ONCE); 
		pDoc->Alg.g_eventContinue.SetEvent();

	::WaitForSingleObject(v->threadFinished, INFINITE);
	
	TRACE("ДОЖДАЛИСЯ\n");

	pDoc->ClearMem();
	v->RedrawWindow(); 
	//pDoc->UpdateAllViews(v);	
	return 1;
}



UINT WorkThread(LPVOID pParam)
{
	
	CConvexHullView* v = (CConvexHullView*)pParam;
	

	CConvexHullDoc* pDoc = v->GetDocument();
	pDoc->Alg.Run(&pDoc->InputData, &pDoc->IntermedData,  &pDoc->OutputData,  v->RunMode  ); 
	
		

	v->RedrawWindow();

	if (v)
	v->PostMessage(WM_THREADFINISHED,0,0);

	return 0;
}

UINT CConvexHullView::OnThreadFinished(UINT wParam, LONG lParam)
{
	CConvexHullDoc* pDoc = GetDocument();
	pDoc->UpdateAllViews(this); 
	
	TRACE("THREAD IS FINISHED\n");
	pDoc->thread = NULL;
	
	if (!isClear) AfxMessageBox("Конец работы алгоритма");
	
	threadFinished.SetEvent(); 

	isClear = false;
	
	KillTimer(ID_TIMER_1);
	
	Auto = false;

	return 1;
}

void CConvexHullView::OnPlay() 
{
	this->OnButtonplay(); 	
}

void CConvexHullView::OnRestart() 
{
	this->OnButtonstop();
}

void CConvexHullView::OnStep()  
{	
	this->OnButtonstep();
}

void CConvexHullView::OnScreenshots() 
{
	// TODO: Add your command handler code here
	 CString fName;

	CFileDialog	fd(FALSE,"bmp",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,NULL,this);
	
	CString str = "Windows bitmap"; str+=(TCHAR)NULL; str+="*.bmp";str+=(TCHAR)NULL;   
	fd.m_ofn.lpstrFilter = str;
	fd.m_ofn.lpstrTitle = "Save as Bitmap";

	if(fd.DoModal()!=IDCANCEL)
	{
		TRACE("SAVE\n");
		CRect	rect;
		fName = fd.GetPathName();
		
		this->RedrawWindow(); 
		this->GetClientRect(rect);
		WriteWindowToDIB((LPCTSTR)fName,rect,this);
		
	}
	else{
		// do nothing;
	}

}

void CConvexHullView::OnUpdateGenerate(CCmdUI* pCmdUI) 
{
	CConvexHullDoc* pDoc = GetDocument();

	if (pDoc->thread!=NULL){
		pCmdUI->Enable(FALSE); 
	}
}



void CConvexHullView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	CConvexHullDoc* pDoc = GetDocument();	

	switch(GetActivePane()){
	case 1:
	case 0: {
			if (pDoc->thread==NULL){
				pDoc->SetModifiedFlag();
				
				TPoint* pnt = new TPoint;
				*pnt = ConvPicToScn(point);
				pDoc->pointdata.UserPoints.push_back(pnt); 

				this->RedrawWindow();
				pDoc->UpdateAllViews(this);
			}

			break;
			}
	case 2 : {
		break;
			 }
	}

	CView::OnRButtonDown(nFlags, point);
}



void CConvexHullView::OnLButtonUp(UINT nFlags, CPoint point) {
	
	blFlagMove = false;

	CConvexHullDoc* pDoc = GetDocument();
	
	if ((pDoc->thread==NULL)&&(start!=end)){
	



	//////////////////////////////////////////////////////
	int MaxX = ConvertX(start.x) > ConvertX(end.x) ? ConvertX(start.x) : ConvertX(end.x) ;
	int MinX = ConvertX(start.x) <= ConvertX(end.x) ? ConvertX(start.x) : ConvertX(end.x) ;
	
	int MaxY = ConvertY(start.y) > ConvertY(end.y) ? ConvertY(start.y) : ConvertY(end.y) ;
	int MinY = ConvertY(start.y) <= ConvertY(end.y) ? ConvertY(start.y) : ConvertY(end.y) ;
	//////////////////////////////////////////////////////



	CConvexHullDoc* pDoc = GetDocument(); 
	CGenerateDlg dlg;

	dlg.SetStyle(2); 
	
	///////////////////////В общем-то код лишний//////////////////
	pDoc->gen_info.max_x = MaxX;
	pDoc->gen_info.max_y = MaxY;
	pDoc->gen_info.min_x = MinX;
	pDoc->gen_info.min_y = MinY;
	/////////////////////////////////////////



	dlg.SetGenValues(&pDoc->gen_info);
	
	if (dlg.DoModal() ==IDOK){
		pDoc->gen_info = dlg.GetGenValues();

		  int num_points = pDoc->gen_info.count; 
		  double x_left = pDoc->gen_info.min_x;
		  double x_right = pDoc->gen_info.max_x;
		  double y_top = pDoc->gen_info.max_y; 
		  double y_bottom = pDoc->gen_info.min_y;
		  
		  pDoc->Alg.Generate((pDoc->InputData[0]), pDoc->gen_info);
		
		this->RedrawWindow();
		pDoc->UpdateAllViews(this);
		
		pDoc->SetModifiedFlag();

	}

	
	this->RedrawWindow();

	}

	CView::OnLButtonUp(nFlags, point);
}


void CConvexHullView::OnLButtonDown(UINT nFlags, CPoint point) {
	CConvexHullDoc* pDoc = GetDocument();
	
	if (pDoc->thread==NULL) {
		end = start = point;
		blFlagMove=true;
	}
	
	CView::OnLButtonDown(nFlags, point);
}




void CConvexHullView::OnMouseMove(UINT nFlags, CPoint point) 
{
	
	CView::OnMouseMove(nFlags, point);
	this->statusInfo(); 

	if (blFlagMove) {
		end = point;
		this->RedrawWindow(); 
	}





#ifndef SIMPLIFICATION

	CString strX, strY;
	CMainFrame* mf = (CMainFrame*)theApp.GetMainWnd();
	CStatusBar* pStatus = &mf->m_wndStatusBar; 
	
	
	switch (GetActivePane()){
		case 0:
		case 1: {			
			if (pStatus){				
				strX.Format("x=%d", ConvertX(point.x));
				strY.Format("y=%d", ConvertY(point.y));
				pStatus->SetPaneText(1,strX); 
				pStatus->SetPaneText(2,strY); 
				
			}
			break;
		}
		case 2: {
			if (pStatus){
				pStatus->SetPaneText(1,""); 
				pStatus->SetPaneText(2,""); 
			}
			break;
		}

	}

#endif

}

int CConvexHullView::ConvertX(int x)
{
	return (x+(SIZE)*(num_top-1-VIEW_X)-x*RESIZE/SIZE-RESIZE*(num_top-1-VIEW_X));
}

int CConvexHullView::ConvertY(int y)
{
	return -(y-(num_left+1+VIEW_Y)*SIZE-y*RESIZE/SIZE+RESIZE*(num_left+1+VIEW_Y));
}



int CConvexHullView::GetDelay()
{
	CMainFrame* frm =  (CMainFrame*)this->GetForegroundWindow();
	if (frm->c_StatusSlider.m_hWnd ==NULL) return oldDelay;
	
	int result = frm->GetDelay(); 
	
	return (result==-10 ? oldDelay: result);
}




void CConvexHullView::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	if (nIDEvent==ID_TIMER_1){
		if (this->GetDocument()->thread!=NULL){
			//TRACE("%d\n",oldDelay);
			this->GetDocument()->Alg.g_eventContinue.SetEvent();
		}
	}


	CView::OnTimer(nIDEvent);
}

/*
void CConvexHullView::OnCustomdrawSlider1(NMHDR* pNMHDR, LRESULT* pResult) 
{
	// TODO: Add your control notification handler code here
	if ((this->GetDocument()->thread!=NULL)&&(Auto)){
	
		int i = GetDelay();
		if (oldDelay==i) return;
		else oldDelay = i;
		
		if (i==0) {
			this->GetDocument()->Alg.setRunMode(AT_ONCE); 
		}
		else
			this->GetDocument()->Alg.setRunMode(BY_STEP); 

		//TRACE("%d\n",i);
		KillTimer(ID_TIMER_1); 
		::SetTimer(this->m_hWnd ,ID_TIMER_1,i*TIMER_DELAY,NULL);
			//KillTimer(ID_TIMER_1); 

	}
	*pResult = 0;
}
*/
void CConvexHullView::OnUpdateButtonstep(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!Auto);
}

void CConvexHullView::OnUpdateStep(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!Auto);
}

void CConvexHullView::OnUpdateButtonplay(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!Auto);
}

void CConvexHullView::OnUpdatePlay(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!Auto);
}

void CConvexHullView::OnButtonbreak() 
{
	Auto = false;
	KillTimer(ID_TIMER_1); 

}

void CConvexHullView::OnUpdateButtonbreak(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(Auto);
	
}




void CConvexHullView::OnCustomdrawSlider1(NMHDR* pNMHDR, LRESULT* pResult){//;OnSliderChange(LONG Param){
	

	//if (this->GetRuntimeClass()->m_pfnGetBaseClass m_lpszClassName == "CConvexHullView" )
	//if (this->IsKindOf(RUNTIME_CLASS( CConvexHullView )) )
	if ((Auto)&&(this->GetDocument()->thread!=NULL)){
	
		int i = GetDelay();
		if (oldDelay==i) return;
		else oldDelay = i;
		
		if (i==0) {
			this->GetDocument()->Alg.setRunMode(AT_ONCE); 
		}
		else
			this->GetDocument()->Alg.setRunMode(BY_STEP); 

		//TRACE("%d\n",i);
		KillTimer(ID_TIMER_1); 
		::SetTimer(this->m_hWnd ,ID_TIMER_1,i*TIMER_DELAY,NULL);
			

	}
	
}

void CConvexHullView::OnInitialUpdate() 
{
	CView::OnInitialUpdate();
	
	// TODO: Add your specialized code here and/or call the base class
	

}

void CConvexHullView::OnBreak() 
{
	this->OnButtonbreak();  
}

void CConvexHullView::OnUpdateBreak(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(Auto);
}

BOOL CConvexHullView::DestroyWindow() 
{
	// TODO: Add your specialized code here and/or call the base class
	//return true;
	return CView::DestroyWindow();
}

void CConvexHullView::OnDestroy() 
{

	

	
	if (this->GetDocument()->thread){
		
		KillTimer(ID_TIMER_1); 
		this->GetDocument()->Alg.setRunMode(AT_ONCE); 
		this->GetDocument()->Alg.g_eventContinue.SetEvent();
		
		//AfxBeginThread(Stop, this, ID_THREAD_PRIORITY);
		//::WaitForSingleObject(threadFinished, INFINITE);
		TerminateThread(this->GetDocument()->thread->m_hThread,0); 
		if (this->GetDocument()->thread){
			//delete this->GetDocument()->thread;
			
		}
		//this->GetDocument()->thread=NULL;

	}
		
	

	CView::OnDestroy();
	// TODO: Add your message handler code here
	
}

BOOL CConvexHullView::PreTranslateMessage(MSG* pMsg) 
{
	
	//toolTip.RelayEvent(pMsg) ;
	return CView::PreTranslateMessage(pMsg);
}




void CConvexHullView::statusInfo()
{
	CMainFrame* tmp = (CMainFrame*)this->GetForegroundWindow();
	if (::IsWindow(tmp->m_hWnd))	tmp->statusInfo();
}
Соседние файлы в папке ConvexHull