tringdlg.cpp

四元图灵机程序

		if(&g_state[i]==local)
			index=i;
	}
	return index;
}
void CTringDlg::OnFileOpen() 
{
	// TODO: Add your command handler code here
	CFileDialog open(true,".txt","demo.txt",OFN_OVERWRITEPROMPT,"Text File (*.txt)|*.txt|All Files (*.*)|*.*||");
	CString filename;
	CString mutual;
	char t[4000];
	int len;
	grid.DeleteAll();
	if(open.DoModal()==IDOK)
	{
		filename=open.GetFileName();
	    CFile file;
		if(file.Open(filename,CFile::modeRead))
		{
			len=file.Read(t,4000);
			for(int i=0;i<len;i++)
				mutual+=t[i];
			file.Close();
		}
	}
	m_input=mutual;
	grid.set_four_team(mutual);
	CClientDC dc(this),*mydc;
	mydc=&dc;
	grid.draw(mydc);
	UpdateData(false);	
}
void CGrid::draw(CDC *dc)
{
	if(tape_index>19)
	{
		left_tape+=10;
		tape_index-=10;
		initial_tape(left_tape);
	}
/*	if(tape_index<0)
	{
		left_tape=tape_index+20;
		tape_index+=20;
		initial_tape(left_tape);
	}*/
	clear(dc);
	draw_tape(dc);
	draw_box(dc);
	draw_grid(dc);
// 	draw_graph_state(dc);
	draw_state(dc);
}
void CGrid::initial_tape(int i)
{
	int len=input_tape.GetLength();
	int local_i=i;
	for(i;i<local_i+20;i++)
	{
		if(i<len)
			tape[i-local_i]=input_tape.GetAt(i);
		else
			tape[i-local_i]='B';
	}

}
void CGrid::draw_tape(CDC *dc)
{
	CRect rect;
	CString str;
	int off_len;	
	for(int i=0;i<20;i++)
	{
		if(i<tape_index)
			off_len=0;
		else 
			off_len=30;
		if(i==tape_index)
			rect.SetRect(12+i*34,24+down,12+i*34+56,56+down);
		else
			rect.SetRect(12+i*34+off_len,24+down,12+i*34+34+off_len,56+down);
		str+=tape[i];
		dc->DrawText(str,1,&rect,DT_CENTER);
		str="";
	}
}
void CGrid::set_four_team(CString str)
{
	four_team=str;
	trans_state();
	run_over=false;

};
void CGrid::draw_graph_state(CDC *dc)
{
	if(current_state==100)
	{
		if(start_state.GetLength()==0)
			start_state=g_state[0].get_state();
		CTuple *tuple=new CTuple;
		tuple->set_state(start_state);
		current_state=next_state=get_state_index(*tuple,g_state,len_state);
		delete tuple;
	}
	if(graph_flag==0)
	{
		CPoint point;
		point.x=270;
		point.y=295;
		g_state[current_state].set_point(point);
		g_state[current_state].set_level(0);
		layout_state_y(&g_state[current_state],99,491,0);
		layout_state_x();
		graph_flag=1;
	}
	display_state(dc);
	draw_line(dc);
//	current_state=next_state=100;
}
void CGrid::draw_box(CDC *dc)
{
	int index=tape_index;
	int i=index;
	int j=i+1;
	/////draw 1
	CPen *pen=new CPen(PS_SOLID ,1,0x4444fffff );
	dc->SelectObject(pen);
	dc->SetROP2(R2_COPYPEN );
	dc->MoveTo(6+i*34,3+down);
	dc->LineTo(18+j*34+18,3+down);
	dc->LineTo(18+j*34+18,65+down);
	dc->LineTo(6+i*34,65+down);
	dc->LineTo(6+i*34,3+down);
	////
	dc->LineTo(6+i*34+24,0);
	dc->LineTo(18+i*34+24+52,0);
	dc->LineTo(18+j*34+18,3+down);
	/////
	dc->MoveTo(18+i*34+24+52,0);
	dc->LineTo(18+i*34+24+52,33);
	dc->MoveTo(18+i*34+24+47,52+down);
	dc->LineTo(18+j*34+18,65+down);
    dc->SetROP2(R2_BLACK  );
}
void CState::draw(CDC *dc)
{
	CPoint p1,p2,p3,p4;
/*	p1.x=point.x-10;
	p1.y=point.y-10;
	p2.x=point.x+10;
	p2.y=point.y-10;
	p3.x=point.x+10;
	p3.y=point.y+10;
	p4.x=point.x-10;
	p4.y=point.y+10;*/
	dc->SetTextAlign(TA_CENTER);
	dc->TextOut(point.x,point.y,state);
/*	dc->MoveTo(p1);
	dc->LineTo(p2);
	dc->LineTo(p3);
	dc->LineTo(p4);
	dc->LineTo(p1);*/
}
void CGrid::layout_state_y(CState *x,int top,int bottom,int level)
{
	int len=x->get_list()->GetCount(),real_len=0;
	CList<COperate *,COperate*> *mylist=x->get_list();
	COperate* t;
	CState *t_state;
	CPoint head_point=x->get_point(),tail;
	for(int i=0;i<len;i++)
	{
		POSITION pos;
		pos=mylist->FindIndex(i);
		t=mylist->GetAt(pos);
		t_state=t->get_next_state();
		if(!t_state->is_point_seted())
		{
			real_len++;
		}
	}
	int wide;
	if(real_len)
		wide=(bottom-top)/real_len;
	CPoint one;
	real_len=0;
	for(i=0;i<len;i++)
	{
		POSITION pos;
		pos=mylist->FindIndex(i);
		t=mylist->GetAt(pos);
		t_state=t->get_next_state();
		if(!t_state->is_point_seted())
		{
			tail.y=top+real_len*wide+wide/2;
			t_state->set_point(tail);
			layout_state_y(t_state,top+real_len*wide,top+real_len*wide+wide,level+1);
			t_state->set_level(level+1);
			real_len++;
		}								
	}
}

void CTringDlg::OnRunStep() 
{
	// TODO: Add your command handler code here
	UpdateData(true);
	CString local_str,str;
	if(m_input.GetLength()>0)
	{
		CClientDC dc(this),*mydc;
		mydc=&dc;
		if(flag==0)
		{
			grid.set_four_team(m_input);
			flag=1;
		}
		if(!grid.get_run_over())
		{
			if(grid.GetNumStep()>=maxstep)
			{
				KillTimer(1);
				str="运行超过了规定的步数，系统退出。可以在菜单中设置更大的运行步数";
				AfxMessageBox(str);
			}
			else
			{
				grid.run(mydc);
				if(grid.get_run_over())
				{
					str+="运行";
					str+=int_string(grid.GetNumStep());
					str+="步；输出：";
					local_str=grid.get_input_tape();
					local_str=modify(local_str);
					str+=local_str;
					AfxMessageBox(str);
					flag=0;
				}
			}
		}
		else
		{
			str+="运行";
			str+=int_string(grid.GetNumStep());
			str+="步；输出：";	
			local_str=grid.get_input_tape();
			local_str=modify(local_str);
			str+=local_str;
			AfxMessageBox(str);
			flag=0;
		}
	}
	else
		AfxMessageBox("机器没准备好");
	
}
void CGrid::modify_tape(COperate *x)
{
	int flag=x->get_flag();
	CString str;
	if(flag==0)
	{
		str=x->get_output();
		input_tape.SetAt(left_tape+tape_index,str.GetAt(0));
	}
	else
	{
		if(flag==1)
		{
			tape_index++;
			if(tape_index+left_tape>=input_tape.GetLength())
			{
				input_tape+="BBBBBBBBBBBBBBBBBBBB";
			}
		}
		if(flag==-1)
		{
			tape_index--;
			if(left_tape+tape_index<0)
			{
				input_tape.Insert(0,"BBBBBBBBBB");
				tape_index+=10;
			}
		}
	}
	initial_tape(left_tape);
}

void CTringDlg::Onreset() 
{
	// TODO: Add your command handler code here
	CClientDC dc(this),*mydc;
	mydc=&dc;
	KillTimer(1);
	grid.reset();
	grid.draw(mydc);
}
void CGrid::reset()
{
	current_state=100;
	feedback();
	tape_index=0;
	left_tape=0;
	initial_tape(left_tape);
	run_over=false;
	NumStep=0;
}
void CGrid::display_state(CDC *dc)
{
	g_state[current_state].draw(dc);
	g_state[current_state].set_level(1);
	display_state(dc,&g_state[current_state]);	
	for(int i=0;i<len_state;i++)
	{
		g_state[i].set_level(0);
	}
}
void CGrid::display_state(CDC *dc,CState *t)
{	
	int len=t->get_list()->GetCount();
	CList<COperate *,COperate*> *mylist=t->get_list();
	COperate* tt;
	CState *t_state;
	for(int i=0;i<len;i++)
	{
		POSITION pos=mylist->FindIndex(i);
		tt=mylist->GetAt(pos);
		t_state=tt->get_next_state();
		if(t_state->get_level()==0)
		{
			t_state->set_level(1);
			t_state->draw(dc);
			display_state(dc,t_state);
		}
	}
}
bool CState::is_point_seted()
{
	if(point.x==9999&&point.y==9999)
		return false;
	else
		return true;
}
void CGrid::layout_state_x()
{
	int max=0,level;
	int wide;
	CPoint point;
	for(int i=0;i<len_state;i++)
	{
		if(g_state[i].get_level()>max)
			max=g_state[i].get_level();
	}
	if(max)
		wide=(740-275)/(max);
	for(i=0;i<len_state;i++)
	{
		point=g_state[i].get_point();
		level=g_state[i].get_level();
		point.x=264+6+wide*level;
		g_state[i].set_point(point);		
	}
	for(i=0;i<len_state;i++)
	{
		g_state[i].set_level(0);
	}
}
void CGrid::draw_line(CDC *dc,CState *head)
{
	CList<COperate *,COperate*> *mylist=head->get_list();
	int len=mylist->GetCount();
	COperate *operate,*op;
	CList<COperate *,COperate*> head_tail[10];
	int index_list=0,j,flag=0;
	for(int i=0;i<len;i++)
	{
		POSITION pos=mylist->FindIndex(i);
		operate=mylist->GetAt(pos);
		for(j=0;j<index_list;j++)
		{
			op=head_tail[j].GetHead();
			if(is_head_tail_same(*operate,*op))
			{
				head_tail[j].AddTail(operate);
				break;
			}
		}
		if(j==index_list)
		{
			head_tail[index_list++].AddTail(operate);
		}
	}
	for(i=0;i<index_list;i++)
	{
		draw_line(dc,head,&head_tail[i]);
	}
}
void CGrid::draw_line(CDC *dc)
{
	for(int i=0;i<len_state;i++)
	{
		draw_line(dc,&g_state[i]);		
	}
}
void CGrid::draw_line(CDC *dc,CState *head,CList<COperate *,COperate*> *mylist)
{
	CString str;
	COperate * op;
	int len=mylist->GetCount();
	CState *tail;
	for(int i=0;i<len;i++)
	{
		POSITION pos=mylist->FindIndex(i);
		op=mylist->GetAt(pos);
		str+=op->get_input();
		str+=":";
		str+=op->get_output();
		str+=",";
	}
	str.Delete(str.GetLength()-1,1);

	tail=op->get_next_state();
	CPoint index_head,index_tail,point,text_point,t1,t2;
	index_head=head->get_point();
	index_tail=tail->get_point();
	int r=23;
	if(index_head==index_tail)
	{
		dc->SetArcDirection(AD_CLOCKWISE   );
		dc->Arc(index_head.x-r,index_head.y,index_head.x+r,index_head.y-2*r,index_head.x,index_head.y,index_head.x,index_head.y);
		dc->SetTextAlign(TA_CENTER |TA_LEFT |TA_TOP);
		dc->TextOut(index_head.x,index_head.y-r,str);
	}
	else
	{
		if(index_head.x<index_tail.x)
		{
			t1=index_head;
			t2=index_tail;
			if(index_head.y>index_tail.y)
			{
				t1=index_head;
				t2=index_tail;
				dc->SetArcDirection(AD_CLOCKWISE   );
			}
			else
			{
				t2=index_head;
				t1=index_tail;
				dc->SetArcDirection(AD_COUNTERCLOCKWISE   );
			}
			dc->Arc(t1.x,t1.y,2*t2.x-t1.x,t2.y,t1.x,t1.y,t2.x,t2.y);
		}
	}
	


}
bool CGrid::is_head_tail_same(COperate p1,COperate p2)
{
	if(p1.get_next_state()==p2.get_next_state())
		return true;
	else
		return false;
}
void CGrid::draw_arrow(CDC *dc,CPoint start,CPoint end,COLORREF color)
{

}
void CGrid::draw_grid(CDC *dc)
{
	int x,y,off_len;
	for(int i=0;i<20;i++)
	{
		if(i<tape_index)
			off_len=0;
		else
			off_len=64;
		x=12+34*i+off_len;
		y=17+down;
		dc->MoveTo(x,y);
		y=51+down;
		dc->LineTo(x,y);
	}
	int j;
	i=tape_index;
	j=i+1;
	dc->MoveTo(12,17+down);
	dc->LineTo(12+34*i,17+down);
	dc->MoveTo(12+34*i+64,17+down);
	dc->LineTo(696+64,17+down);
//	dc->LineTo(696,17);
	dc->LineTo(696+64,51+down);
	dc->LineTo(12+34*i+64,51+down);
	dc->MoveTo(12+34*i,51+down);
	dc->LineTo(12,51+down);
	if(i)
	dc->LineTo(12,17+down);
}
void CGrid::draw_state(CDC *dc)
{
	CString str;
	if(current_state!=100)
	{
		str=g_state[next_state].get_state();

	}
	else
	{
		str=start_state;
	}
	dc->SetTextAlign(TA_CENTER);
	dc->TextOut(6+tape_index*34+38,4,str);
}
void CGrid::clear(CDC *dc)
{

	int index=tape_index_lasttime;
	int i=index;
	int j=i+1;
	/////draw 1
	CPen *pen=new CPen(PS_SOLID ,1,dc->GetPixel( 0,0));
	dc->SelectObject(pen);
	dc->SetROP2(R2_COPYPEN);
	for(i=0;i<85;i++)
	{
		dc->MoveTo(0,i);
		dc->LineTo(765,i);
	}
/*	dc->MoveTo(6+i*34,3+down);
	dc->LineTo(18+j*34+18,3+down);
	dc->LineTo(18+j*34+18,65+down);
	dc->LineTo(6+i*34,65+down);
	dc->LineTo(6+i*34,3+down);
	////
	dc->LineTo(6+i*34+24,0);
	dc->LineTo(18+i*34+24+52,0);
	dc->LineTo(18+j*34+18,3+down);
	/////
	dc->MoveTo(18+i*34+24+52,0);
	dc->LineTo(18+i*34+24+52,33);
	dc->MoveTo(18+i*34+24+47,52+down);
	dc->LineTo(18+j*34+18,65+down);
 //   dc->SetROP2(R2_BLACK  );
	/////////////////////////////////////
	CRect rect;
	CString str;
	int off_len;	
	for(i=0;i<20;i++)
	{
		if(i<tape_index_lasttime)
			off_len=0;
		else 
			off_len=30;
		if(i==tape_index_lasttime)
			rect.SetRect(12+i*34,24+down,12+i*34+56,56+down);
		else
			rect.SetRect(12+i*34+off_len,24+down,12+i*34+34+off_len,56+down);
		str+=tape[i];
		dc->FillSolidRect(rect,dc->GetPixel( 0,0));
		str="";
	}
	///////////////////////
	dc->FillSolidRect(tape_index_lasttime*34+8,0,50,60,dc->GetPixel( 0,0));
	/////////////////////////////
	int x,y;
	for(i=0;i<20;i++)
	{
		if(i<tape_index_lasttime)
			off_len=0;
		else
			off_len=64;
		x=12+34*i+off_len;
		y=17+down;
		dc->MoveTo(x,y);
		y=51+down;
		dc->LineTo(x,y);
	}
	i=tape_index_lasttime;
	j=i+1;
	dc->MoveTo(12,17+down);
	dc->LineTo(12+34*i,17+down);
	dc->MoveTo(12+34*i+64,17+down);
	dc->LineTo(696+64,17+down);
//	dc->LineTo(696,17);
	dc->LineTo(696+64,51+down);
	dc->LineTo(12+34*i+64,51+down);
	dc->MoveTo(12+34*i,51+down);
	dc->LineTo(12,51+down);
	if(i)
	dc->LineTo(12,17+down);

	dc->SetROP2(R2_BLACK  );*/
}

void CTringDlg::OnFileSave() 
{
	// TODO: Add your command handler code here
	UpdateData(true);
	CFileDialog open(false,".txt","demo.txt",OFN_OVERWRITEPROMPT,"Text File (*.txt)|*.txt|All Files (*.*)|*.*||");
	CString filename;
	CString mutual;
	char t[4000];
	int len;
	if(open.DoModal()==IDOK)
	{
		filename=open.GetFileName();
	    CStdioFile file;
		if(file.Open(filename,CFile::modeCreate|CFile::modeWrite));
		{

			file.WriteString(m_input);
			file.Close();
		}
	}
	
}

void CTringDlg::OnHelp() 
{
	// TODO: Add your command handler code here
	WinExec("hh.exe Turing.chm",1);
}
void CGrid::DeleteAll()
{
	ReSet();
	four_team="";
	len_state=0;
	tape_index=0;
	start_state_index=0;
	run_over=false;
	input_tape="BBBBBBBBBBBBBBBBBBBBBB";
	current_state=100;
	next_state=100;
	graph_flag=0;
	start_state="q1";
	tape_index_lasttime=0;
	left_tape=0;
	NumStep=0;
	for(int i=0;i<100;i++)
	{
		g_state[i].DeleteAll();
	}
}
void CState::DeleteAll()
{
	state="";
	list.RemoveAll();
}

void CTringDlg::OnMaxStep() 
{
	// TODO: Add your command handler code here
	MaxStep max;
	max.SetMax(maxstep);
	if(max.DoModal()==IDOK)
	{
		maxstep=max.GetMax();
	}	
}