femmviewview.cpp

一个2D电磁场FEM计算的VC++源程序

		BOOL drawgrid=TRUE;
		BOOL PlotB;
		double MaxVal;
		int xp,yp;
		CComplex vr,va,c0,c1;
		int ilo,ihi,jlo,jhi;

		if ((VectorPlot==1) || (VectorPlot==3) || (VectorPlot==5)){
			MaxVal=pDoc->B_High;
			PlotB=TRUE;
		}
		else{
			MaxVal=pDoc->H_High;
			PlotB=FALSE;
		}

		ScreenToDwg((int) r.right, (int) r.top, &xd, &yd, &r);
		nx=(int) (floor(xd/GridSize) - ceil(ox/GridSize));
		ny=(int) (floor(yd/GridSize) - ceil(oy/GridSize));
		
		if (nx>0){
			if((r.right/nx)<2) drawgrid=FALSE;
		}

		if (drawgrid==FALSE){
			StatBar->SetPaneText(0,"Vectors too dense to display.",TRUE);
		}
		else{	
			for(k=0;k<pDoc->meshelem.GetSize();k++)
			{
				rt=abs(CComplex(xss,yss)-pDoc->meshelem[k].ctr);
				if( rt < ( sqrt(pDoc->meshelem[k].rsqr) + rss) )
				{
					c0=pDoc->meshelem[k].ctr-sqrt(pDoc->meshelem[k].rsqr)*(1.+I);
					c1=pDoc->meshelem[k].ctr+sqrt(pDoc->meshelem[k].rsqr)*(1.+I);
					c0/=GridSize;
					c1/=GridSize;
					ilo=(int) floor(Re(c0));
					ihi=(int) ceil (Re(c1));
					jlo=(int) floor(Im(c0));
					jhi=(int) ceil (Im(c1));
					for(i=ilo;i<=ihi;i++)
					{
						for(j=jlo;j<=jhi;j++)
						{
							xd=GridSize*((double) i);
							yd=GridSize*((double) j);
							if(pDoc->InTriangleTest(xd,yd,k))
							{
								pDoc->GetPointValues(xd,yd,k,u);
								
								// Plot real vector
								if ((VectorPlot!=3) && (VectorPlot!=4))
								{
									pOldPen = pDC->SelectObject( &penRealVector );
									if (PlotB) vr=Re(u.B1)+I*Re(u.B2);
									else vr=Re(u.H1)+I*Re(u.H2);
									vr*=(GridSize*VectorScaleFactor/MaxVal);
									DwgToScreen(xd,yd,&xs,&ys,&r);
									MyMoveTo(pDC,xs,ys);
									xp=xs;yp=ys;
									DwgToScreen(xd+Re(vr),yd+Im(vr),&xs,&ys,&r);
									MyLineTo(pDC,xs,ys);
									if ((xs==xp) && (ys==yp)) pDC->SetPixel((int) xs, (int) ys, RealVectorColor );
									else if (abs(vr)!=0)
									{
										xp=xs;yp=ys;
										va=exp(I*3.*PI/4.)*vr/3.;
										DwgToScreen(xd+Re(vr+va),yd+Im(vr+va),&xs,&ys,&r);
										MyLineTo(pDC,xs,ys);
										MyMoveTo(pDC,xp,yp);
										va*=exp(I*PI/2.);
										DwgToScreen(xd+Re(vr+va),yd+Im(vr+va),&xs,&ys,&r);
										MyLineTo(pDC,xs,ys);	   
									}
									pDC->SelectObject( pOldPen );
								}

								// Plot imag vector
								if ((VectorPlot!=1) || (VectorPlot!=2) || (pDoc->Frequency!=0))
								{
									pOldPen = pDC->SelectObject( &penImagVector );
									if (PlotB) vr=Im(u.B1)+I*Im(u.B2);
									else vr=Im(u.H1)+I*Im(u.H2);
									vr*=(GridSize*VectorScaleFactor/MaxVal);
									DwgToScreen(xd,yd,&xs,&ys,&r);
									MyMoveTo(pDC,xs,ys);
									xp=xs;yp=ys;
									DwgToScreen(xd+Re(vr),yd+Im(vr),&xs,&ys,&r);
									MyLineTo(pDC,xs,ys);
									if ((xs==xp) && (ys==yp)) pDC->SetPixel((int) xs, (int) ys, ImagVectorColor );
									else if (abs(vr)!=0)
									{
										xp=xs;yp=ys;
										va=exp(I*3.*PI/4.)*vr/3.;
										DwgToScreen(xd+Re(vr+va),yd+Im(vr+va),&xs,&ys,&r);
										MyLineTo(pDC,xs,ys);
										MyMoveTo(pDC,xp,yp);
										va*=exp(I*PI/2.);
										DwgToScreen(xd+Re(vr+va),yd+Im(vr+va),&xs,&ys,&r);
										MyLineTo(pDC,xs,ys);	   
									}
									pDC->SelectObject( pOldPen );
								}

							} 
						}
					}
				} // end of if(rt<...
			}
		}				
	}


	if(EditAction==1) DrawUserContour(TRUE);

	// draw block labels/names
	if(ShowNames){
		pDC->SetTextColor(NameColor);
		pOldPen = pDC->SelectObject( &penGreen );
		CString lbl;
		for(i=0;i<pDoc->blocklist.GetSize();i++)
		{
			DwgToScreen(pDoc->blocklist[i].x,pDoc->blocklist[i].y,&xs,&ys,&r);

			MyMoveTo(pDC,xs-2,ys-2);
			MyLineTo(pDC,xs-2,ys+2);
			MyLineTo(pDC,xs+2,ys+2);
			MyLineTo(pDC,xs+2,ys-2);
			MyLineTo(pDC,xs-2,ys-2);

			// draw arrows indicating magnetization direction
			// if the block is a permanent magnet
			if (pDoc->blockproplist[pDoc->blocklist[i].BlockType].H_c!=0)
			{
				int vx,vy;
				CComplex ar;
				ar=(cos(pDoc->blocklist[i].MagDir*PI/180))+
					I*(sin(pDoc->blocklist[i].MagDir*PI/180));
				vx=xs - ((int) (10.*ar.re));
				vy=ys + ((int) (10.*ar.im));
				MyMoveTo(pDC,vx,vy);
				vx=xs + ((int) (10.*ar.re));
				vy=ys - ((int) (10.*ar.im));
				MyLineTo(pDC,vx,vy);
				ar/=(1.+I)/sqrt(2.);
				MyLineTo(pDC,vx-((int) (6.*ar.re)),vy+((int) (6*ar.im)));
				MyMoveTo(pDC,vx,vy);
				ar*=I;
				MyLineTo(pDC,vx-((int) (6.*ar.re)),vy+((int) (6*ar.im)));
			}

			pDC->SetTextAlign(TA_BASELINE);
			pDC->SetBkMode(TRANSPARENT);
			lbl=pDoc->blockproplist[pDoc->blocklist[i].BlockType].BlockName;
			pDC->TextOut(xs+5,ys,lbl);
			
			pDC->SetTextAlign(TA_TOP);

			if (pDoc->blocklist[i].InCircuit>=0)
            {
				k=pDoc->blocklist[i].InCircuit;
				if(pDoc->circproplist[k].CircType==1)
					lbl.Format("[%s:%i]",pDoc->circproplist[k].CircName,
						pDoc->blocklist[i].Turns);
				else lbl="["+pDoc->circproplist[k].CircName+"]";
				pDC->TextOut(xs+5,ys,lbl);
			}
		
		}
		pDC->SelectObject( pOldPen );
	}


	// Draw Legend if it is enabled;
	if((LegendFlag==TRUE) && (DensityPlot!=0))
	{
		CBrush *pOldBrush;
		char cc[80];		
		double dta;
		CBrush BackBrush;
	
		pOldPen = pDC->SelectObject( &penText );
		pDC->SetTextColor(TextColor);
		pDC->SetTextAlign(TA_TOP);
		pDC->SetTextAlign(TA_LEFT);
		pDC->SetBkMode(TRANSPARENT);
  
		BackBrush.CreateSolidBrush(BackColor);
		pOldBrush = pDC->SelectObject( &BackBrush );
		pDC->Rectangle(r.right-212-6,r.top+6,r.right-6,r.top+24+21*16 );
		pDC->SelectObject(pOldBrush);

		if (DensityPlot==1) sprintf(cc,"Density Plot: |B|, Tesla");
		if (DensityPlot==2) sprintf(cc,"Density Plot: |B_re|, Tesla");
		if (DensityPlot==3) sprintf(cc,"Density Plot: |B_im|, Tesla");
		if (DensityPlot==4) sprintf(cc,"Density Plot: |J|, MA/m^2");
		if (DensityPlot==5) sprintf(cc,"Density Plot: |J_re|, MA/m^2");
		if (DensityPlot==6) sprintf(cc,"Density Plot: |J_im|, MA/m^2");
		pDC->TextOut(r.right-212,r.top+16*20+16,cc,strlen(cc));

		dta=(pDoc->B_ub - pDoc->B_lb)/20.;

		for(i=0;i<20;i++){
			
			{		
				CBrush FillBrush;

				if (GreyContours==FALSE) FillBrush.CreateSolidBrush(mymap[i]);
				else FillBrush.CreateSolidBrush(greymap[i]);
				pOldBrush = pDC->SelectObject( &FillBrush );
				pDC->Rectangle(r.right-212,r.top+16*i+12,r.right-187,r.top+12+16*(i+1) );
				pDC->SelectObject(pOldBrush);
			}
			
			if(DensityPlot<4){
				if(i==0) 
					sprintf(cc,"%.3e : >%.3e",((double) (19-i))*dta + pDoc->B_lb,
					((double) (20-i))*dta + pDoc->B_lb);
				else if(i==19) 
					sprintf(cc,"<%.3e : %.3e",((double) (19-i))*dta + pDoc->B_lb,
					((double) (20-i))*dta + pDoc->B_lb);
				else 
					sprintf(cc,"%.3e : %.3e",((double) (19-i))*dta + pDoc->B_lb,
					((double) (20-i))*dta + pDoc->B_lb);
				pDC->TextOut(r.right-182,r.top+16*i+12,cc,strlen(cc));
			}
			else{
				if(i==0) sprintf(cc,">%.3e",(pDoc->B_ub - dta)*1.e-06);
				else if(i==19) sprintf(cc,"<%.3e",(pDoc->B_lb + dta)*1.e-06);
				else sprintf(cc,"%.3e : %.3e",(((double) (19-i))*dta + pDoc->B_lb)*1.e-06,
					(((double) (20-i))*dta + pDoc->B_lb)*1.e-06);
				pDC->TextOut(r.right-182,r.top+16*i+12,cc,strlen(cc));
			}
		}
		pDC->SelectObject( pOldPen );
	}

// fire up lua
//	if (pDoc->luafired==false)
//	{	
//		pDoc->luafired=true;
//		pDoc->luathread(pDoc);
//	}

	pDC->SelectObject(pOldFont);
	fntArial.DeleteObject();
	EndWaitCursor();
}

/////////////////////////////////////////////////////////////////////////////
// CFemmviewView printing

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CFemmviewView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CFemmviewView message handlers

void CFemmviewView::OnMouseMove(UINT nFlags, CPoint point) 
{
	if (bLinehook!=FALSE)
	{
		StatBar->SetPaneText(0,"EXECUTING LUASCRIPT -- HIT <BREAK> TO ABORT",TRUE);
		CView::OnMouseMove(nFlags, point);
		return;
	}

	static char statmsg[256];
	double x,y,q;
	RECT r;
	CFemmviewDoc *pDoc=GetDocument();	
	
	// get size of current client area and convert mouse position into
	// position on the actual drawing.
	GetClientRect(&r);
	q=pow(10.,floor(log(mag)/log(10.)+0.5));
	x=(double) point.x; y=(double) (r.bottom-point.y-1);
	x=x/mag+ox; y=y/mag+oy;
	x=floor(x*q+0.5)/q; y=floor(y*q+0.5)/q;

	// process Snap to Grid command
	if ((SnapFlag==TRUE) && (EditAction!=2) && (ZoomWndFlag==0)){
		x=GridSize*floor(0.5+x/GridSize);
		y=GridSize*floor(0.5+y/GridSize);
	}

	// draw box for window zoom;
	if(ZoomWndFlag==2){
		CDC *pDC=GetDC();
		COLORREF ocol;
		CZPix p;

		int xso,yso,xsi,ysi,xsn,ysn,i,k,lo,hi;
		DwgToScreen(wzx,wzy,&xso,&yso,&r);
		DwgToScreen(mx,my,&xsi,&ysi,&r);
		DwgToScreen(x,y,&xsn,&ysn,&r);

		// Draw old rectangle off the screen;
		if(ZoomPix.GetSize()>0){
			for(k=ZoomPix.GetSize()-1;k>=0;k--)
				pDC->SetPixel(ZoomPix[k].x,ZoomPix[k].y,ZoomPix[k].c);
			ZoomPix.RemoveAll();
		}

		// XOR new rectangle onto screen
		if(xso<xsn){ lo=xso,hi=xsn; }
		else{ lo=xsn; hi=xso; }
		for(i=lo;i<=hi;i++){
			ocol=pDC->GetPixel(i,ysn);
			p.c=ocol; p.x=i; p.y=ysn;
			ZoomPix.Add(p);
			ocol=ocol ^ RGB(255,255,255);
			pDC->SetPixel(i,ysn,ocol);
			ocol=pDC->GetPixel(i,yso);
			p.c=ocol; p.x=i; p.y=yso;
			ZoomPix.Add(p);
			ocol=ocol ^ RGB(255,255,255);
			pDC->SetPixel(i,yso,ocol);
		}
		if(yso<ysn){ lo=yso,hi=ysn; }
		else{ lo=ysn; hi=yso; }
		for(i=lo;i<=hi;i++){
			ocol=pDC->GetPixel(xso,i);
			p.c=ocol; p.x=xso; p.y=i;
			ZoomPix.Add(p);
			ocol=ocol ^ RGB(255,255,255);
			pDC->SetPixel(xso,i,ocol);
			ocol=pDC->GetPixel(xsn,i);
			p.c=ocol; p.x=xsn; p.y=i;
			ZoomPix.Add(p);
			ocol=ocol ^ RGB(255,255,255);
			pDC->SetPixel(xsn,i,ocol);
		}

		ReleaseDC(pDC);
	}
	

	// update mouse position;
	mx=x; my=y;

	if ((pDoc->Coords==FALSE) && (pDoc->ProblemType==0))
		sprintf(statmsg,"(x=%.4f,y=%.4f)",x,y);
	else if ((pDoc->Coords==FALSE) && (pDoc->ProblemType==1))
		sprintf(statmsg,"(r=%.4f,z=%.4f)",x,y);
	else sprintf(statmsg,"(%.4f at %.4f deg)",sqrt(x*x+y*y),atan2(y,x)*180/PI);
	StatBar->SetPaneText(0,statmsg,TRUE);

	CView::OnMouseMove(nFlags, point);
}

void CFemmviewView::OnZoomIn() 
{
	RECT r;
	double x,y;

	GetClientRect(&r);
	x=r.right; y=r.bottom;

	ox=ox+0.25*x/mag;
	oy=oy+0.25*y/mag;
	mag*=2.;

	RedrawView();
}

void CFemmviewView::OnZoomOut() 
{
	RECT r;
	double x,y;

	GetClientRect(&r);
	x=r.right; y=r.bottom;
	ox=ox-0.5*x/mag;
	oy=oy-0.5*y/mag;
	mag/=2.;

	RedrawView();
}

void CFemmviewView::OnZoomNatural() 
{
	CFemmviewDoc *pDoc=GetDocument();
	double x[2],y[2],m[2],w;
	RECT r;
	int i;

	if (pDoc->meshnode.GetSize()<2) return;
	x[0]=pDoc->meshnode[0].x;	x[1]=pDoc->meshnode[0].x;
	y[0]=pDoc->meshnode[0].y;	y[1]=pDoc->meshnode[0].y;
	for(i=1;i<pDoc->meshnode.GetSize();i++)
	{
		if(pDoc->meshnode[i].x<x[0]) x[0]=pDoc->meshnode[i].x;
		if(pDoc->meshnode[i].x>x[1]) x[1]=pDoc->meshnode[i].x;
		if(pDoc->meshnode[i].y<y[0]) y[0]=pDoc->meshnode[i].y;
		if(pDoc->meshnode[i].y>y[1]) y[1]=pDoc->meshnode[i].y;
	}

	if(pDoc->FirstDraw==TRUE){
		if((x[1]-x[0])>(y[1]-y[0])) w=x[1]-x[0];
		else w=y[1]-y[0];
		if(w!=0)
			GridSize=pow(10.,floor(log(w)/log(10.)-1.));
	}

	ox=x[0]; oy=y[0];
	GetClientRect(&r);
	m[0]=((double) (r.right-1))/(x[1]-x[0]);
	m[1]=((double) (r.bottom-1))/(y[1]-y[0]);

	if(m[0]<m[1]) mag=m[0];
	else mag=m[1];
	
	if(pDoc->FirstDraw==TRUE) pDoc->FirstDraw=FALSE;
	else RedrawView();	
}


void CFemmviewView::OnKbdZoom() 
{
	CFemmviewDoc *pDoc=GetDocument();
	CKbdZoom dlg;
	RECT r;
	double m[2],x[4],z;

	GetClientRect(&r);
	ScreenToDwg(r.right,r.top, &dlg.m_scr_right, &dlg.m_scr_top, &r);
	dlg.m_scr_top=floor(1000.*dlg.m_scr_top)/1000.;
	dlg.m_scr_right=floor(1000.*dlg.m_scr_right)/1000.;
	dlg.m_scr_bottom=oy;
	dlg.m_scr_left=ox;

	if(dlg.DoModal()==IDOK)
	{
		x[0]=dlg.m_scr_left;
		x[1]=dlg.m_scr_bottom;
		x[2]=dlg.m_scr_right;
		x[3]=dlg.m_scr_top;
		
		if(x[0]>x[2]){ z=x[2]; x[2]=x[0]; x[0]=z; }
		if(x[1]>x[3]){ z=x[3]; x[3]=x[1]; x[1]=z; }

		ox=x[0]; oy=x[1]; 
		m[0]=((double) (r.right-1))/(x[2]-x[0]);
		m[1]=((double) (r.bottom-1))/(x[3]-x[1]);
		if(m[0]<m[1]) mag=m[0];
		else mag=m[1];
		RedrawView();
	}
}

void CFemmviewView::OnZoomWindow() 
{
	ZoomWndFlag=TRUE;	
	ZoomPix.RemoveAll();
}

void CFemmviewView::OnShowGrid() 
{
	CMainFrame *MFrm;
	MFrm=(CMainFrame *)GetParentFrame();
	CMenu* MMnu=MFrm->GetMenu();
	CToolBar *pToolBar;
	pToolBar=&MFrm->m_toolBar;    
	CToolBarCtrl *tc=&pToolBar->GetToolBarCtrl();

	if(GridFlag==TRUE){
		GridFlag=FALSE;
		MMnu->CheckMenuItem(ID_SHOW_GRID, MF_UNCHECKED);
		tc->CheckButton(ID_SHOW_GRID,FALSE);
	}