mygraph.cpp

来自「故障诊断工作涉及的领域相当广泛」· C++ 代码 · 共 1,115 行 · 第 1/2 页

								pptlst->add(pdpt1);
							}
						}
						else if(g_c_flag&SNAPCONIN)
						{	
							if(pflag&SNAPIN||pflag&SNAPCONIN||pflag&SNAPOUT)
							{
								goto goon;
							}
							else if(pflag&SNAPCONOUT)
							{
								pn2=pn;
								which2=pw;
								if(abs(pptlst->tail->x-point.x)>5)
								pptlst->tail->y=point.y-5;
								dpt* pdpt=new dpt;
								*pdpt=dpt(point.x,point.y-5);
								pptlst->add(pdpt);
								finishconpath(pv,point,pDC);
								goto skip;
							}
							else if(stepg==0)
							{	
								pn2=pn;
								which2=pw;
								dpt* pdpt1=new dpt;
								beginpath(pv,point,pDC);
								*pdpt1=dpt(first.x,first.y-5);
								pptlst->add(pdpt1);;
							}
						}
						else if(g_c_flag&SNAPCONOUT)
						{	
							if(pflag&SNAPOUT||pflag&SNAPIN||pflag&SNAPCONOUT)
							{
								goto goon;
							}
							else if(pflag&SNAPCONIN)
							{	
								pn1=pn;
								which1=pw;
								if(abs(pptlst->tail->x-point.x)>5)
								pptlst->tail->y=point.y+5;
								dpt* pdpt=new dpt;
								*pdpt=dpt(point.x,point.y+5);
								pptlst->add(pdpt);
								finishconpath(pv,point,pDC);
								goto skip;
							}
							else if(stepg==0)
							{	
								pn1=pn;
								which1=pw;
								beginpath(pv,point,pDC);
								dpt* pdpt1=new dpt;
								*pdpt1=dpt(first.x,first.y+5);
								pptlst->add(pdpt1);
							}
						}
						pflag=g_c_flag;
skip:						goto goon;
					}
					if(bway)
					{	
						drawpath(point,pDC);
					}
					if(bway==FALSE)
					{
						addnode(pv,point);
					}
				}
goon:
				oldstepg=stepg;
	;			
}
extern CPoint oldoffset;
void mygraph::mousemove(CCadView* pv,UINT nFlags, CPoint point)
{
static BOOL flag=FALSE;
static BOOL firstmove=TRUE;
static CPoint prept;
CPoint pt=point;
CPoint cpt;
	if(firstmove)
	{
		prept=point;
		firstmove=FALSE;
	}
CDC* pDC=pv->GetDC();
CPen* whitepen=new CPen;
			 whitepen->CreatePen(0,1,RGB(255,255,255));
				if(nFlags==RBUTTONDOWN&&flag==FALSE)
				{
					oldoffset=pt;
					flag=TRUE;
				}
				else if(flag==TRUE&&nFlags!=RBUTTONDOWN)
				{
					offset=dpt(point-oldoffset);
					rspt+=offset;
					//pDoc->graph
					move();
					pv->frcdraw();
					//offset=CPoint(0,0);
					flag=FALSE;
				}
				else if(g_c_flag&SNAPDIPAN)
				{	CPen* old=pDC->SelectObject(whitepen);
					int oldmode=pDC->SetROP2(R2_NOT);
					if(bfirstmove)
					{	prept.x=first.x;
						prept.y=first.y;
						bfirstmove=FALSE;
					}
					if(pflag==SNAPIN)
							point.x-=5;
						else if(pflag==SNAPOUT)
							point.x+=5;
					pDC->MoveTo(first.x,first.y);
					pDC->LineTo(prept);
					pDC->SelectObject(old);
					pDC->MoveTo(first.x,first.y);
					pDC->LineTo(point);
					pDC->SetROP2(oldmode);
					prept=point;
				}
				else if(bway)
				{	
					CPen* old=pDC->SelectObject(whitepen);
					if(abs(point.x-prept.x)>abs(point.y-prept.y))
						cpt=CPoint(point.x,olddpt.y);
					else
						cpt=CPoint(olddpt.x,point.y);
					int oldmode=pDC->SetROP2(R2_NOT);
					if(bwaystart)
					{
						prept.x=olddpt.x;
						prept.y=olddpt.y;
					}
					pDC->MoveTo(olddpt.x,olddpt.y);
					pDC->LineTo(prept);
					pDC->SelectObject(old);
					pDC->MoveTo(olddpt.x,olddpt.y);
					pDC->LineTo(cpt);
					pDC->SetROP2(oldmode);
					prept=cpt;
					goto goon;
				}
				else if(nFlags==1)
				{
				bselecting=TRUE;
				}
				else
				{
				bselecting=FALSE;
				}
goon:
				;
}
void mygraph::rbuttondown(CCadView *pv,UINT nFlags, CPoint pt)
{	
	
}
void mygraph::rbuttonup(CCadView *pv,UINT nFlags, CPoint pt)
{	
	CRect rect;
	pv->GetClientRect(&rect);
	if(stepg==0)
	{
		deleteselectnode();
	}
	else if(stepg==1)
	{
		if(pptlst!=NULL)
			pptlst->~ptlist();
		pptlst=NULL;
	}
	else if(stepg==2)
	{	
		if(g_c_flag&DRAWDATA)
			cutdataconection();
		else if(g_c_flag&DRAWCON)
			cutconconection();
	}
clearflag(pv);
pv->frcdraw();
	
}

BOOL mygraph::isoverlap(node *pn, dpt pt)
{node* p=head;
while(p!=NULL)
	{	
		if(pn!=p)
		{
			if(p->is_snap(pt,bway))
			{
				if(pn!=p)
				return TRUE;
			}
		}
		p=p->pnn;
	}
return FALSE;
}

void mygraph::finishiopath(CCadView* pv,CPoint& point,CDC* pDC)
{
								bway=FALSE;
								pflag=0;
								dpt* pdpt=new dpt;
								*pdpt=dpt(point);
								pptlst->add(pdpt);
								pn2->pptlist[which2]=*pptlst;
								pn2->binfrosen[which2]=TRUE;
								pn2->infrosencnt++;
								pn2->infreecnt--;
								pptlst=NULL;
								pn2->pre[which2].p=(int32)pn1;
								pn2->pre[which2].index=pn1->number;
								//数据来自于那个节点
								*(pn2->prepin+which2)=which1;//节点的哪个输出阵脚
								upgrade(pn1,pn2);
								if(pn2->frosencnt==0)
									pn2->bfrosen=TRUE;
								pn2->frosencnt++;
								pn1->next[which1-pn1->incnt].add(pn2,which2);
								pn1->boutfrosen[which1-pn1->incnt]=TRUE;
								if(pn1->pstructure==NULL&&pn1->type==indata)
									pn1->pstructure=new datastructure[pn2->incnt];
								if(pn1->pstructure!=NULL&&pn1->type==indata)
									pn1->pstructure[which2]=pn2->pstructure[which2];
								if(pn1->frosencnt==0)
									pn1->bfrosen=TRUE;
								pn1->frosencnt++;
								if((pn1->pfirst==NULL||pn1->pfirst==pn2)&&pn1->type==indata)
								{
									pn2->set_data_structure(which2);
									pn1->pfirst=pn2;
								}
								pDC->MoveTo(olddpt.x,olddpt.y);
								pDC->LineTo(point);
								pv->frcdraw();
								bwaystart=FALSE;
								stepg=0;
								g_c_flag=0;
}
void mygraph::finishconpath(CCadView* pv,CPoint& point,CDC* pDC)
{
								bway=FALSE;
								pflag=0;
								dpt* pdpt=new dpt;
								*pdpt=dpt(point);
								pptlst->add(pdpt);
								pn2->ptlstcon[which2-pn2->incnt-pn2->outcnt]=*pptlst;
								pn2->bconinfrosen[which2-pn2->incnt-pn2->outcnt]=TRUE;
								pptlst=NULL;
								pn2->precon[which2-pn2->incnt-pn2->outcnt].p=(int32)pn1;
								pn2->precon[which2-pn2->incnt-pn2->outcnt].index=pn1->number;///数据来自于那个节点
								pn2->preconpin[which2-pn2->incnt-pn2->outcnt]=which1;//节点的哪个输出阵脚								
								if(pn2->frosencnt==0)
									pn2->bfrosen=TRUE;
								pn2->frosencnt++;
								pn1->nextcon[which1-pn1->incnt-pn2->outcnt-5].add(pn2,which2);
								pn1->bconoutfrosen[which1-pn1->incnt-pn2->outcnt-5]=TRUE;
								if(pn1->frosencnt==0)
									pn1->bfrosen=TRUE;
								pn1->frosencnt++;
								pDC->MoveTo(olddpt.x,olddpt.y);
								pDC->LineTo(point);
								pv->frcdraw();
								bwaystart=FALSE;
								stepg=0;
								if(pn1==pn2)
									pn1->invalidcnt++;
}
void mygraph::beginpath(CCadView* pv,CPoint& point,CDC* pDC)
{
								pptlst=new ptlist;
								first=dpt(point);
								if(!bwaystart)
								{
									olddpt=first;
									bwaystart=TRUE;
								}
								bway=TRUE;
								dpt* pdpt=new dpt;
								*pdpt=first;
								pptlst->add(pdpt);
								stepg=1;							
}

void mygraph::drawpath(CPoint point, CDC *pDC)
{dpt cpt;
if(abs(point.x-olddpt.x)>abs(point.y-olddpt.y))
							cpt=dpt(point.x,olddpt.y);
						else
							cpt=dpt(olddpt.x,point.y);
						dpt temp=cpt;
						if(pflag&SNAPIN)
							cpt.x-=5;
						else if(pflag&SNAPOUT)
							cpt.x+=5;
						if(pflag&SNAPCONIN)
							cpt.y-=5;
						else if(pflag&SNAPCONOUT)
							cpt.y+=5;
						dpt* pdpt=new dpt;
						*pdpt=cpt;
						pptlst->add(pdpt);
						pDC->MoveTo(olddpt.x,olddpt.y);
						pDC->LineTo(temp.x,temp.y);
						olddpt=temp;
}

void mygraph::addnode(CCadView* pv,CPoint point)
{
	CRichtestDoc* pdoc=pv->GetDocument();
	pmv=pdoc->getview();

node* pnode=new node;
					if(pnode!=NULL)
					{	
					    pnode->number=nodecnt++;
							moudledlg dlg(pv->ppcmd,pv->cnt,pnode);
							BOOL uuu=dlg.DoModal();

						if(head==NULL)
							pv->RedrawWindow();
						if(uuu==IDOK)
						{	pnode->create(pmv,pv,dpt(point));
							
								if(head==NULL)
								{
								head=pnode;
								pn=pnode;
								tail=pnode;
								}
								else
								{
								tail->pnn=pnode;
								pnode->ppn=tail;
								pn=pnode;
								tail=pn;
								
								}
								if(pnode->type==indata)
									innode.add(pnode,0);
								else if(pnode->type==outdata)
									outnode.add(pnode,0);
								empty=FALSE;
						pv->frcdraw();
						}
						else 
								delete pnode;
					}
}

void mygraph::upgrade(node *pn1, node *pn2)
{int g;
if(pn1==pn2)
	return;
if(pn1->grade==-1)//有连接时级别为0
	pn1->grade++;
int oldgrade=pn2->grade;
if(pn2->grade<pn1->grade+1)
{
	pn2->grade=pn1->grade+1;
	g=pn2->grade-oldgrade;
	if(oldgrade==-1)
		g--;
	pn2->upgrade(g);
}
}
void mygraph::degrade(node *pn1, node *pn2)
{
if(pn2->infrosencnt==0)
{	
	pn2->upgrade(-pn2->grade);
    pn2->grade=0;
	goto goon;
}
if(pn2->grade==pn1->grade+1)
{
	for(unsigned int i=0;i<pn2->incnt;i++)
	{
		node* pnd=(node*)pn2->pre[i].p;
		if(pnd!=NULL)
		{
			if(pnd->grade==pn1->grade)
				goto goon;
		}
	}
	pn2->grade-=1;
	pn2->upgrade(-1);
}
goon:
if(pn2->bfrosen==FALSE)//自由节点级别为-1
	pn2->grade=-1;
if(pn1->bfrosen==FALSE)//自由节点级别为-1
	pn1->grade=-1;
}

BOOL mygraph::gradeerror(node *pn1, node *pn2)
{
	
/*	if(pn1->pre!=NULL)
	{
		for(unsigned int i=0;i<pn1->incnt;i++)
		{
			if(pn1->pre[i]!=NULL)
			{
				if(pn1->pre[i]==(int)pn2)
					return TRUE;
				else
					gradeerror((node*)pn1->pre[i],pn2);
			}
		}
	}*/
	if(pn1->grade!=-1&&pn2->grade!=-1)
	{
		if(pn1->grade>pn2->grade)
			return TRUE;
	}
		return FALSE;
}

void mygraph::clearflag(CCadView* pv)
{
	pn1=pn2=NULL;
	which1=which2=NULL;
	bway=0;
	bwaystart=0;
	g_c_flag=0;
	pflag=0;
	stepg=0;
}

void mygraph::selectrect(const CRect &rect,CView* pv)
{
	node* pn=head;
	while(pn!=NULL)
	{	CPoint pt=CPoint(pn->center.x,pn->center.y);
		if(rect.PtInRect(pt)&&pn->bfrosen==FALSE)
		{ pn->setdipan(pv);
		  pn->bselect=TRUE;
		}
		pn=pn->pnn;
	}
}

void mygraph::deleteselectnode()
{
	node* pn=head;
	node* pn1;
	while(pn!=NULL)
	{	pn1=pn->pnn;
		if(pn->bselect==TRUE)
		{
			if(pn->pnn==NULL&&pn->ppn==NULL)
			{				
				head=tail=NULL;				
			}
			else if(pn->pnn==NULL)
			{
				tail=pn->ppn;
				tail->pnn=NULL;
			}
				
			else if(pn->ppn==NULL)
			{	
				head=pn1;
				head->ppn=NULL;
			}
			else
			{
				pn->ppn->pnn=pn->pnn;
				pn->pnn->ppn=pn->ppn;				
			}
		delete pn;
		};
		pn=pn1;		
	}

}
int mygraph::run()
{   node* pnode=NULL;
	nd* pn=innode.head;
	while(pn!=NULL)
	{
		if(pn->p!=0)
		{
			pnode=(node*)pn->p;
			pnode->pv=pv;pnode->pmv=pmv;

		pnode->pthrd=AfxBeginThread(proc,pnode);
		pnode->m_hThread=pnode->pthrd->m_hThread;
		pnode->pthrd->m_bAutoDelete=FALSE;
		}
		pn=pn->next;
	}
	return 0;
}

void mygraph::stop()
{
	node* pn=head;
	while(pn!=NULL)
	{
		if(pn->invalidcnt==-1)
			pn->pthrd->PostThreadMessage(WM_QUIT,0,0);	
		if(pn->pthrd!=NULL)
			delete pn->pthrd;
		pn=pn->pnn;
	}
}

BOOL mygraph::test()
{
	bvalid=TRUE;
	return TRUE;

}

void mygraph::rebuildpath()
{int32 p;unsigned i;
node* pn=head;node* pn1;
	while(pn!=NULL)
	{for(nd* ppp=innode.head;ppp!=NULL;ppp=ppp->next)
		if(ppp->index==pn->number)
			ppp->p=(int32)pn;
		pn->pv=pv;
		pn->pmv=pmv;
	for(i=0;i<pn->incnt;i++)
		if(pn->pre[i].index!=-1)
		{
		for(pn1=head;pn1->number!=pn->pre[i].index&&pn!=NULL;pn1=pn1->pnn);
			pn->pre[i].p=(int32)pn1;
		};
	for(i=0;i<pn->outcnt;i++)
		{
		pn->next[i].rebuild(head);
		}
	for(i=0;i<pn->concnt;i++)
	{
		if(pn->precon[i].index!=-1)
		{
		for(pn1=head;pn1->number!=pn->precon[i].index&&pn!=NULL;pn1=pn1->pnn);
			pn->precon[i].p=(int32)pn1;
		};
	pn->nextcon[i].rebuild(head);
	}
		
	pn=pn->pnn;
	}
}