femmeview.cpp

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

	return TRUE;
}

void CFemmeView::OnDraw(CDC* pDC)
{
	CFemmeDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	
	if(pDoc->NoDraw==TRUE) return;

	// TODO: add draw code for native data here
	RECT r;
	GetClientRect(&r);
	int i,j,k;				// usual iterators...
	int xs,ys,nx,ny;
	double xd,yd,side,R,dt;
	CComplex c,p,s;
	CString lbl;

	CFont fntArial,*pOldFont;
	fntArial.CreateFont(16,6,0,0,0,0,0,0,0,0,0,0,0,"Arial");
	pOldFont=pDC->SelectObject(&fntArial);
	
	if (pDC->IsPrinting()!=FALSE){
		CSize sz;
		RECT cr;
		int wd=pDC->GetDeviceCaps( HORZRES );
		int hd=pDC->GetDeviceCaps( VERTRES );
		int ww=r.right-r.left;
		int hw=r.bottom-r.top;
		int x=wd/ww;
		int y=hd/hw;
		if (y<x) x=y;
		pDC->SetMapMode(MM_ISOTROPIC);
		sz.cx=ww; sz.cy=hw;
		pDC->SetWindowExt(sz);
		sz.cx=x*ww; sz.cy=x*hw;
		pDC->SetViewportExt(sz);
		pDC->GetClipBox(&cr);
		pDC->IntersectClipRect(&r);
	}
	else{
        CheckIt();
    } 
	if (pDoc->FirstDraw==TRUE) OnZoomNatural();

	CPen *pOldPen;
	CPen penBlue,penRed,penNode,penGreen,penMesh,penGrey;
	penBlue.CreatePen(PS_SOLID,1,LineColor);
	penRed.CreatePen(PS_SOLID,1,SelColor);
	penNode.CreatePen(PS_SOLID,1,NodeColor);
	penGreen.CreatePen(PS_SOLID,1,BlockColor);
	penMesh.CreatePen(PS_SOLID,1,MeshColor);
	penGrey.CreatePen(PS_SOLID,1,RGB(220,220,220));

	// Convert node coordinates to screen coordinates
	for(i=0;i<pDoc->nodelist.GetSize();i++)
	  if(DwgToScreen(pDoc->nodelist[i].x,pDoc->nodelist[i].y,
				  &(pDoc->nodelist[i].xs),&(pDoc->nodelist[i].ys),&r)==FALSE)
	{
		mag/=1.1;
		i=-1;
	}
			
	// Convert meshnode coordinates to screen coordinates
	if(MeshFlag==TRUE)
	for(i=0;i<pDoc->meshnode.GetSize();i++)
	  DwgToScreen(pDoc->meshnode[i].x,pDoc->meshnode[i].y,
				  &(pDoc->meshnode[i].xs),&(pDoc->meshnode[i].ys),&r);

	// Draw grid if it is enabled...
	if (GridFlag==TRUE)
	{
		int skip;
		BOOL drawgrid=TRUE;

		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,"Grid too dense to display.",TRUE);
		}
		else{
			skip=__min((nx/20)+1,(ny/20)+1);
			skip=(int) pow(2.,floor(log((double) skip)/log(2.)));
			for(i=0,xd=GridSize*ceil(ox/GridSize);i<=nx;i++,xd+=GridSize)
				for(j=0,yd=GridSize*ceil(oy/GridSize);j<=ny;j++,yd+=GridSize)
				{
					if((i==skip*(i/skip)) || (j==skip*(j/skip)))
					{
						DwgToScreen(xd,yd,&xs,&ys,&r);
						pDC->SetPixel((int) xs, (int) ys, GridColor );
					}
				}
		}
	}

	// Draw origin marker if it is enabled
	if(d_showorigin==TRUE)
	{
		// is the origin in the view area?
		if (DwgToScreen(0.,0.,&xs,&ys,&r)==TRUE)
		{
			if ((xs>-10) && (ys>-10) && (xs<r.right+10) && (ys<r.bottom+10))
			{
				// ok, the origin is in the view area;
				// draw a cross at the origin.
				pOldPen = pDC->SelectObject( &penNode );
				MyMoveTo(pDC,xs-9,ys);
				MyLineTo(pDC,xs+9,ys);
				MyMoveTo(pDC,xs,ys-9);
				MyLineTo(pDC,xs,ys+9);
				pDC->SelectObject( pOldPen );
			}
		}
	}
	
	// Draw mesh if it is enabled...
	if (MeshFlag==TRUE)
	{
		pOldPen = pDC->SelectObject( &penMesh);
		for(i=0;i<pDoc->meshline.GetSize();i++)
		{
			MyMoveTo(pDC,pDoc->meshnode[pDoc->meshline[i].x].xs,
					pDoc->meshnode[pDoc->meshline[i].x].ys);
			MyLineTo(pDC,pDoc->meshnode[pDoc->meshline[i].y].xs,
					pDoc->meshnode[pDoc->meshline[i].y].ys);
		
		}	
		pDC->SelectObject( pOldPen );

		pOldPen = pDC->SelectObject( &penGrey);
		for(i=0;i<pDoc->greymeshline.GetSize();i++)
		{
			MyMoveTo(pDC,pDoc->meshnode[pDoc->greymeshline[i].x].xs,
					pDoc->meshnode[pDoc->greymeshline[i].x].ys);
			MyLineTo(pDC,pDoc->meshnode[pDoc->greymeshline[i].y].xs,
					pDoc->meshnode[pDoc->greymeshline[i].y].ys);
		
		}	
		pDC->SelectObject( pOldPen );

	}

	// Draw lines linking nodes
	for(i=0;i<pDoc->linelist.GetSize();i++)
	{
		if(pDoc->linelist[i].IsSelected==FALSE)
			pOldPen = pDC->SelectObject( &penBlue );
		else pOldPen = pDC->SelectObject( &penRed );

		MyMoveTo(pDC,pDoc->nodelist[pDoc->linelist[i].n0].xs,
					pDoc->nodelist[pDoc->linelist[i].n0].ys);
		MyLineTo(pDC,pDoc->nodelist[pDoc->linelist[i].n1].xs,
					pDoc->nodelist[pDoc->linelist[i].n1].ys);
		
		pDC->SelectObject( pOldPen );
	}

	// Draw Arc Segments;
	for(i=0;i<pDoc->arclist.GetSize();i++)
	{
		if(pDoc->arclist[i].IsSelected==FALSE)
			pOldPen = pDC->SelectObject( &penBlue );
		else pOldPen = pDC->SelectObject( &penRed );
		k=(int) ceil(pDoc->arclist[i].ArcLength/pDoc->arclist[i].MaxSideLength);
		dt=pDoc->arclist[i].ArcLength*PI/(((double) k)*180.);

		pDoc->GetCircle(pDoc->arclist[i],c,R);
		p.Set(pDoc->nodelist[pDoc->arclist[i].n0].x,
			  pDoc->nodelist[pDoc->arclist[i].n0].y);
		DwgToScreen(p.re,p.im,&xs,&ys,&r);
		MyMoveTo(pDC,xs,ys);
		s=exp(I*dt);
		for(j=0;j<k;j++){
			p=(p-c)*s+c;
			DwgToScreen(p.re,p.im,&xs,&ys,&r);
			MyLineTo(pDC,xs,ys);
		}
		pDC->SelectObject( pOldPen );
	}

	// Draw node points
	for(i=0;i<pDoc->nodelist.GetSize();i++)
	{
		xs=pDoc->nodelist[i].xs;
		ys=pDoc->nodelist[i].ys;

		if(pDoc->nodelist[i].IsSelected==FALSE)
			pOldPen = pDC->SelectObject( &penNode );
		else pOldPen = pDC->SelectObject( &penRed );

		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);

		pDC->SelectObject( pOldPen );
	}
	
	// Draw block labels
	for(i=0;i<pDoc->blocklist.GetSize();i++)
	{
		DwgToScreen(pDoc->blocklist[i].x,pDoc->blocklist[i].y,&xs,&ys,&r);

		if(pDoc->blocklist[i].IsSelected==FALSE)
			pOldPen = pDC->SelectObject( &penGreen );
		else pOldPen = pDC->SelectObject( &penRed );

		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);

		// circle approximately showing area constraint...
		if((pDoc->blocklist[i].MaxArea>0) && 
		   (pDoc->blocklist[i].BlockType!="<No Mesh>")){
			side=sqrt(pDoc->blocklist[i].MaxArea/PI);
			j=(int) ceil(side*mag);

/*			
			// zoom-safe replacement
			CComplex p;
			int kmax;
			MyMoveTo(pDC,xs+j,ys);
			kmax=(int) (2.*PI*((double) j)/5.);
			if (kmax>36) kmax=36;
			if ((kmax<8) && (kmax>0)) kmax=8;
			for(k=1;k<=kmax;k++)
			{
				p=exp(I*k*2.*PI/((double) kmax))*((double) j);
				MyLineTo(pDC,xs+((int) Re(p)),ys+((int) Im(p)));
			}
*/
			pDC->Arc(xs-j,ys-j,xs+j+1,ys+j+1,xs+j+1,ys,xs+j+1,ys);
		}

		// draw a line indicating the magnetization direction;
		for(j=0,k=-1;j<pDoc->blockproplist.GetSize();j++)
			if (pDoc->blocklist[i].BlockType==pDoc->blockproplist[j].BlockName)
				k=j;
		if (k>=0)
			if (pDoc->blockproplist[k].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)));
			}

		if(ShowNames){
			pDC->SetTextColor(NameColor);
			pDC->SetTextAlign(TA_BASELINE);
			pDC->SetBkMode(TRANSPARENT);
			for(k=0,lbl="<None>";k<pDoc->blockproplist.GetSize();k++)
				if (pDoc->blockproplist[k].BlockName==pDoc->blocklist[i].BlockType)
					lbl=pDoc->blocklist[i].BlockType;
			if (pDoc->blocklist[i].BlockType=="<No Mesh>") lbl="<No Mesh>";
			pDC->TextOut(xs+5,ys,lbl);

			pDC->SetTextAlign(TA_TOP);
			for(k=0,lbl="";k<pDoc->circproplist.GetSize();k++)
				if (pDoc->circproplist[k].CircName==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->blocklist[i].InCircuit+"]";
				}
			pDC->TextOut(xs+5,ys,lbl);
			pDC->SetTextColor(RGB(0,0,0));
		}

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

void CFemmeView::OnInitialUpdate()
{
	CView::OnInitialUpdate();

	EditAction=d_action;
	GridFlag=d_showgrid;
	SnapFlag=d_snapgrid;
	ShowNames=d_shownames;

	CheckIt();
}	

void CFemmeView::CheckIt()
{
	// once again, this is sort of a punt
	// to make sure that the right buttons
	// are checked.  It can be relatively
	// easy to change the internal flags 
	// associated with the buttons without
	// taking the time to service the button
	// state otherwise.

	CMainFrame *MFrm;
	MFrm=(CMainFrame *)GetTopLevelFrame();
	if (MFrm==NULL) AfxMessageBox("Null GetTopLevelFrame");
	else StatBar=(CStatusBar *)MFrm->GetMessageBar();

	// update check boxes in the main menu...
	
	CMenu* MMnu=MFrm->GetMenu();
	MMnu->CheckMenuItem(ID_NODE_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_SEGMENT_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_BLOCK_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_ARCSEG_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_GROUP_OP, MF_UNCHECKED);

	CToolBar *pToolBar;
	pToolBar=&MFrm->m_toolBar;    
	CToolBarCtrl *tc=&pToolBar->GetToolBarCtrl();
	tc->PressButton(ID_NODE_OP,FALSE);
	tc->PressButton(ID_SEGMENT_OP,FALSE);
	tc->PressButton(ID_BLOCK_OP,FALSE);
	tc->PressButton(ID_ARCSEG_OP,FALSE);
	tc->PressButton(ID_GROUP_OP,FALSE);

	if(EditAction==0){
		tc->PressButton(ID_NODE_OP,TRUE);
		MMnu->CheckMenuItem(ID_NODE_OP, MF_CHECKED);
	}
	if(EditAction==1){
		tc->PressButton(ID_SEGMENT_OP,TRUE);
		MMnu->CheckMenuItem(ID_SEGMENT_OP, MF_CHECKED);
	}
	if(EditAction==2){
		tc->PressButton(ID_BLOCK_OP,TRUE);
		MMnu->CheckMenuItem(ID_BLOCK_OP, MF_CHECKED);
	}
	if(EditAction==3){
		tc->PressButton(ID_ARCSEG_OP,TRUE);
		MMnu->CheckMenuItem(ID_ARCSEG_OP, MF_CHECKED);
	}
	if(EditAction==4){
		tc->PressButton(ID_GROUP_OP,TRUE);
		MMnu->CheckMenuItem(ID_GROUP_OP, MF_CHECKED);
	}

	pToolBar=&MFrm->m_toolBar2;    
	tc=&pToolBar->GetToolBarCtrl();
	if(GridFlag==TRUE){
		MMnu->CheckMenuItem(ID_SHOW_GRID, MF_CHECKED);
		tc->PressButton(ID_SHOW_GRID,TRUE);
	}
	else{
		MMnu->CheckMenuItem(ID_SHOW_GRID, MF_UNCHECKED);
		tc->PressButton(ID_SHOW_GRID,FALSE);
	}

	if(SnapFlag==TRUE){
		MMnu->CheckMenuItem(ID_SNAP_GRID, MF_CHECKED);
		tc->PressButton(ID_SNAP_GRID,TRUE);
	}
	else{
		MMnu->CheckMenuItem(ID_SNAP_GRID, MF_UNCHECKED);
		tc->PressButton(ID_SNAP_GRID,FALSE);
	}

	if(ShowNames==TRUE){
		MMnu->CheckMenuItem(ID_VIEW_SHOWNAMES, MF_CHECKED);
	}
	else{
		MMnu->CheckMenuItem(ID_VIEW_SHOWNAMES, MF_UNCHECKED);
	}
}

/////////////////////////////////////////////////////////////////////////////
// CFemmeView printing

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CFemmeView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CFemmeView message handlers

void CFemmeView::OnNodeOp() 
{
	// TODO: Add your command handler code here
	CFemmeDoc *pDoc;
	pDoc=GetDocument();
	pDoc->UnselectAll();
	EditAction=0;

	// update check boxes in the main menu...
	CMainFrame *MFrm;
	MFrm=(CMainFrame *)GetTopLevelFrame();
	CMenu* MMnu=MFrm->GetMenu();
	
	MMnu->CheckMenuItem(ID_NODE_OP, MF_CHECKED);
	MMnu->CheckMenuItem(ID_SEGMENT_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_BLOCK_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_ARCSEG_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_GROUP_OP, MF_UNCHECKED); 

	CToolBar *pToolBar;
	pToolBar=&MFrm->m_toolBar;    
	CToolBarCtrl *tc=&pToolBar->GetToolBarCtrl();
	tc->PressButton(ID_NODE_OP,TRUE);
	tc->PressButton(ID_SEGMENT_OP,FALSE);
	tc->PressButton(ID_BLOCK_OP,FALSE);
	tc->PressButton(ID_ARCSEG_OP,FALSE);
	tc->PressButton(ID_GROUP_OP,FALSE);

//	InvalidateRect(NULL);
	DrawPSLG();
}

void CFemmeView::OnSegmentOp() 
{
	// TODO: Add your command handler code here
	CFemmeDoc *pDoc;
	pDoc=GetDocument();
	pDoc->UnselectAll();
	EditAction=1;
	FirstPoint=-1;

	// update check boxes in the main menu...
	CMainFrame *MFrm;
	MFrm=(CMainFrame *)GetTopLevelFrame();
	CMenu* MMnu=MFrm->GetMenu();
	
	MMnu->CheckMenuItem(ID_NODE_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_SEGMENT_OP, MF_CHECKED);
	MMnu->CheckMenuItem(ID_BLOCK_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_ARCSEG_OP, MF_UNCHECKED);
	MMnu->CheckMenuItem(ID_GROUP_OP, MF_UNCHECKED); 

	CToolBar *pToolBar;
	pToolBar=&MFrm->m_toolBar;    
	CToolBarCtrl *tc=&pToolBar->GetToolBarCtrl();
	tc->PressButton(ID_NODE_OP,FALSE);
	tc->PressButton(ID_SEGMENT_OP,TRUE);
	tc->PressButton(ID_BLOCK_OP,FALSE);
	tc->PressButton(ID_ARCSEG_OP,FALSE);
	tc->PressButton(ID_GROUP_OP,FALSE);

//	InvalidateRect(NULL);
	DrawPSLG();
}

void CFemmeView::OnArcsegOp() 
{
	// TODO: Add your command handler code here
	CFemmeDoc *pDoc;
	pDoc=GetDocument();
	pDoc->UnselectAll();
	EditAction=3;
	FirstPoint=-1;