drawchipview.cpp

本人买的<<VC++项目开发实例>>源代码配套光盘.

											dc.DPtoLP(tmpRect);
											tmpPPaSocket->m_Rect = tmpRect;
											tmpPPaSocket->m_RectLP = tmpRect;											
										}
									}

									if (tmpPObject->IsKindOf(RUNTIME_CLASS(CCrSocket)))
									{
										tmpPCrSocket = (CCrSocket *)tmpPObject;
										if (tmpPCrSocket ->GetIsSelected())
										//如果这个元器件处于选中状态
										{										
											top = tmpPCrSocket ->m_Rect.top;
											left = tmpPCrSocket ->m_Rect.left;
											right = tmpPCrSocket ->m_Rect.right;
											bottom = tmpPCrSocket ->m_Rect.bottom;
											tmpRect = CRect(left,top,right,bottom);
											dc.LPtoDP(tmpRect);
											tmpRect.OffsetRect(deltaX,deltaY);
											tmpPCrSocket ->m_RectTracker.m_rect = tmpRect;
											dc.DPtoLP(tmpRect);
											tmpPCrSocket ->m_Rect = tmpRect;
											tmpPCrSocket ->m_RectLP = tmpRect;											
										}
									}
									if (tmpPObject->IsKindOf(RUNTIME_CLASS(CTransistor)))
									{
										tmpPTransistor = (CTransistor *)tmpPObject;
										if (tmpPTransistor ->GetIsSelected())
										//如果这个元器件处于选中状态
										{										
											top = tmpPTransistor ->m_Rect.top;
											left = tmpPTransistor ->m_Rect.left;
											right = tmpPTransistor ->m_Rect.right;
											bottom = tmpPTransistor ->m_Rect.bottom;
											tmpRect = CRect(left,top,right,bottom);
											dc.LPtoDP(tmpRect);
											tmpRect.OffsetRect(deltaX,deltaY);
											tmpPTransistor ->m_RectTracker.m_rect = tmpRect;
											dc.DPtoLP(tmpRect);
											tmpPTransistor ->m_Rect = tmpRect;
											tmpPTransistor ->m_RectLP = tmpRect;											
										}
									}

									pDoc->SetModifiedFlag(TRUE);
									pObList->GetNext(tmpPos);
								}								
								Invalidate();
								this->UpdateWindow();								
								orgX = msg.pt.x;
								orgY = msg.pt.y;
								break;
							default:
								break;
							}
						}
					}
					else               //当前链表中处于选中状态的有一个
					{
						//单个移动
						if (pComponent->IsKindOf(RUNTIME_CLASS(CResistor)))	
						{
							pResistor = (CResistor *)pComponent;
							m_RectTracker.m_rect = pResistor->m_RectTracker.m_rect;
							m_RectTracker.m_nStyle = CRectTracker::resizeInside;
							if (pResistor->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pResistor->m_RectLP = pResistor->m_RectTracker.m_rect;								
								dc.DPtoLP(pResistor->m_RectLP);
								pResistor->m_Rect = pResistor->m_RectLP;
							}							
						}
						if (pComponent->IsKindOf(RUNTIME_CLASS(CCompacity)))	
						{
							pCompacity = (CCompacity *)pComponent;
							if (pCompacity->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pCompacity->m_RectLP = pCompacity->m_RectTracker.m_rect;								
								dc.DPtoLP(pCompacity->m_RectLP);
								pCompacity->m_Rect = pCompacity->m_RectLP;
							}							
						}
						if (pComponent->IsKindOf(RUNTIME_CLASS(CSwitch)))	
						{
							pSwitch = (CSwitch *)pComponent;
							if (pSwitch->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pSwitch->m_RectLP = pSwitch->m_RectTracker.m_rect;								
								dc.DPtoLP(pSwitch->m_RectLP);
								pSwitch->m_Rect = pSwitch->m_RectLP;
							}							
						}
						if (pComponent->IsKindOf(RUNTIME_CLASS(CDiode)))	
						{
							pDiode = (CDiode *)pComponent;
							if (pDiode->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pDiode->m_RectLP = pDiode->m_RectTracker.m_rect;								
								dc.DPtoLP(pDiode->m_RectLP);
								pDiode->m_Rect = pDiode->m_RectLP;
							}							
						}

						if (pComponent->IsKindOf(RUNTIME_CLASS(CInductor)))	
						{
							pInductor = (CInductor *)pComponent;
							if (pInductor->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pInductor->m_RectLP = pInductor->m_RectTracker.m_rect;
								dc.DPtoLP(pInductor->m_RectLP);
								pInductor->m_Rect = pInductor->m_RectLP;
							}							
						}
						if (pComponent->IsKindOf(RUNTIME_CLASS(CPower)))	
						{
							pPower = (CPower *)pComponent;
							if (pPower->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pPower->m_RectLP = pPower->m_RectTracker.m_rect;
								dc.DPtoLP(pPower->m_RectLP);
								pPower->m_Rect = pPower->m_RectLP;
							}							
						}
						if (pComponent->IsKindOf(RUNTIME_CLASS(CIcChip)))	
						{
							pIcChip = (CIcChip *)pComponent;
							if (pIcChip->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pIcChip->m_RectLP = pIcChip->m_RectTracker.m_rect;
								dc.DPtoLP(pIcChip->m_RectLP);
								pIcChip->m_Rect = pIcChip->m_RectLP;
							}							
						}
						if (pComponent->IsKindOf(RUNTIME_CLASS(CPaSocket)))	
						{
							pPaSocket = (CPaSocket *)pComponent;
							if (pPaSocket->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pPaSocket->m_RectLP = pPaSocket->m_RectTracker.m_rect;
								dc.DPtoLP(pPaSocket->m_RectLP);
								pPaSocket->m_Rect = pPaSocket->m_RectLP;
							}							
						}

						if (pComponent->IsKindOf(RUNTIME_CLASS(CCrSocket)))	
						{
							pCrSocket = (CCrSocket *)pComponent;
							if (pCrSocket->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pCrSocket->m_RectLP = pCrSocket->m_RectTracker.m_rect;
								dc.DPtoLP(pCrSocket->m_RectLP);
								pCrSocket->m_Rect = pCrSocket->m_RectLP;
							}							
						}
						if (pComponent->IsKindOf(RUNTIME_CLASS(CTransistor)))	
						{
							pTransistor = (CTransistor *)pComponent;
							if (pTransistor->m_RectTracker.Track(this,point,FALSE,NULL))
							{
								pTransistor->m_RectLP = pTransistor->m_RectTracker.m_rect;
								dc.DPtoLP(pTransistor->m_RectLP);
								pTransistor->m_Rect = pTransistor->m_RectLP;
							}							
						}

						pDoc->SetModifiedFlag(TRUE);						
						Invalidate();
						goto End;
					}
				}
				else      //当前点按的元器件没有处于选中状态
				{
					SetAllChipNotIsSel(pObList);
					pComponent->SetIsSelected(TRUE);
					Invalidate();
					goto End;
				}
			}
		}
	}
	//Invalidate();	
	InvalidateRect(&rectInvalidate,TRUE);
End:	
	CScrollView::OnLButtonDown(nFlags, point);
	delete lpPoint;
}

//##ModelId=3E18E0DE00D2
void CDrawChipView::SetAllChipNotIsSel(CObList *pObList)
{
	POSITION pos = pObList->GetHeadPosition();
	CObject *pObject;
	CResistor *pResistor;
	CCompacity *pCompacity;
	CSwitch *pSwitch;
	CDiode *pDiode;
	CInductor *pInductor;
	CPower *pPower;
	CIcChip *pIcChip;
	CPaSocket *pPaSocket;
	CCrSocket *pCrSocket;
	CTransistor *pTransistor;

	while(pos!=NULL)
	{
		pObject = pObList->GetAt(pos);
		if (pObject->IsKindOf(RUNTIME_CLASS(CResistor)))
		{
			pResistor = (CResistor *)pObject;
			pResistor->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CCompacity)))
		{
			pCompacity = (CCompacity *)pObject;
			pCompacity->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CSwitch)))
		{
			pSwitch = (CSwitch *)pObject;
			pSwitch->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CDiode)))
		{
			pDiode = (CDiode *)pObject;
			pDiode->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CInductor)))
		{
			pInductor = (CInductor *)pObject;
			pInductor->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CPower)))
		{
			pPower = (CPower *)pObject;
			pPower->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CIcChip)))
		{
			pIcChip = (CIcChip *)pObject;
			pIcChip->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CPaSocket)))
		{
			pPaSocket = (CPaSocket *)pObject;
			pPaSocket->SetIsSelected(FALSE);				
		}
		if (pObject->IsKindOf(RUNTIME_CLASS(CCrSocket)))
		{
			pCrSocket = (CCrSocket *)pObject;
			pCrSocket->SetIsSelected(FALSE);				
		}

		if (pObject->IsKindOf(RUNTIME_CLASS(CTransistor)))
		{
			pTransistor = (CTransistor *)pObject;
			pTransistor->SetIsSelected(FALSE);				
		}

		pObList->GetNext(pos);
	}
}


//##ModelId=3C466BA702BA
void CDrawChipView::OnUpdateDrawTrasistor(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->SetCheck(m_bTransistor);
	
}

//##ModelId=3C466BA70364
void CDrawChipView::OnChipProperty() 
{
	// TODO: Add your command handler code here
	//检查链表中是否有选中的元器件
	CDrawChipDoc *pDoc = GetDocument();
	CObList *pObList = &(pDoc->m_ChipObList);
	int iBeSelCount = BeSelectedNum(pObList);
	POSITION pos;
	CObject *pObject;
	CResistor *pResistor;
	CCompacity *pCompacity;
	CSwitch *pSwitch;
	CDiode *pDiode;
	CInductor *pInductor;
	CPower *pPower;
	CIcChip *pIcChip;
	CPaSocket *pPaSocket;
	CCrSocket *pCrSocket;
	CTransistor *pTransistor;

	CdlgResistorPro dlgResistor;
	CdlgCompacityPro dlgCompacity;
	CdlgSwitchPro dlgSwitch;
	CdlgDiodePro dlgDiode;
	CdlgInductorPro dlgInductor;
	CdlgPowerPro dlgPower;
	CdlgIcChipPro dlgIcChip;
	CdlgSocketPro dlgMySocket;
	CdlgTransistor dlgTransistor;
	switch (iBeSelCount)
	{
	case 0://没有被选中的
		MessageBox("请您首先选择元器件图形!","提示",MB_ICONINFORMATION);
		break;
	case 1://有一个被选中的
		pos = GetFirstSelPos(pObList);
		if (pos != NULL)
		{
			pObject = pObList->GetAt(pos);
			if (pObject->IsKindOf(RUNTIME_CLASS(CResistor)))
			{
				pResistor = (CResistor *)pObject;
				dlgResistor.m_strName = pResistor->GetName();
				dlgResistor.m_strType = pResistor->GetReType();
				dlgResistor.m_strValue = pResistor->GetReValue();								
				this->UpdateData(FALSE); 				
				if (dlgResistor.DoModal() == IDOK)
				{
					this->UpdateData(TRUE);

					pResistor->SetName(dlgResistor.m_strName);
					pResistor->SetReType(dlgResistor.m_strType);
					pResistor->SetReValue(dlgResistor.m_strValue);					
				}
				else
				{
					//点按了“取消”按钮，不做任何事情
				}
			}
			if (pObject->IsKindOf(RUNTIME_CLASS(CCompacity)))
			{
				pCompacity = (CCompacity *)pObject;
				dlgCompacity.m_strName = pCompacity->GetName();
				dlgCompacity.m_strType = pCompacity->GetType();
				dlgCompacity.m_strCompacity = pCompacity->GetCompacity();								
				dlgCompacity.m_strFrequence = pCompacity->GetFrequence();
				dlgCompacity.m_strPressure = pCompacity->GetPressure();
				this->UpdateData(FALSE); 				
				if (dlgCompacity.DoModal() == IDOK)
				{
					this->UpdateData(TRUE);

					pCompacity->SetName(dlgCompacity.m_strName);
					pCompacity->SetType(dlgCompacity.m_strType);
					pCompacity->SetCompacity(dlgCompacity.m_strCompacity);	
					pCompacity->SetFrequence(dlgCompacity.m_strFrequence);
					pCompacity->SetPressure(dlgCompacity.m_strPressure);
				}
				else
				{
					//点按了“取消”按钮，不做任何事情
				}
			}
			if (pObject->IsKindOf(RUNTIME_CLASS(CSwitch)))
			{
				pSwitch = (CSwitch *)pObject;
				dlgSwitch.m_strName = pSwitch->GetName();
				dlgSwitch.m_strType = pSwitch->GetType();				
				this->UpdateData(FALSE); 				
				if (dlgSwitch.DoModal() == IDOK)
				{
					this->UpdateData(TRUE);

					pSwitch->SetName(dlgSwitch.m_strName);
					pSwitch->SetType(dlgSwitch.m_strType);
					
				}
				else
				{
					//点按了“取消”按钮，不做任何事情
				}
			}
			if (pObject->IsKindOf(RUNTIME_CLASS(CDiode)))
			{
				pDiode = (CDiode *)pObject;
				dlgDiode.m_strName = pDiode->GetName();
				dlgDiode.m_strFrequence = pDiode->GetFrequence ();
				dlgDiode.m_strPower = pDiode->GetPower ();
				dlgDiode.m_strSwitch = pDiode->GetSwitch ();
				dlgDiode.m_strType = pDiode->GetType ();				
				this->UpdateData(FALSE); 				
				if (dlgDiode.DoModal() == IDOK)
				{
					this->UpdateData(TRUE);

					pDiode->SetName(dlgDiode.m_strName);
					pDiode->SetFrequence (dlgDiode.m_strFrequence );
					pDiode->SetPower (dlgDiode.m_strPower );
					pDiode->SetSwitch (dlgDiode.m_strSwitch );
					pDiode->SetType(dlgDiode.m_strType);
					
				}
				else
				{
					//点按了“取消”按钮，不做任何事情
				}
			}
			if (pObject->IsKindOf(RUNTIME_CLASS(CInductor)))
			{
				pInductor = (CInductor *)pObject;
				dlgInductor.m_strName = pInductor->GetName();
				dlgInductor.m_strFrequence = pInductor->GetFrequence ();
				dlgInductor.m_strCompacity  = pInductor->GetCompacity ();
				dlgInductor.m_strPressure  = pInductor->GetPressure ();
				dlgInductor.m_strWork  = pInductor->GetWork();				
				this->UpdateData(FALSE); 				
				if (dlgInductor.DoModal() == IDOK)
				{
					this->UpdateData(TRUE);

					pInductor->SetName(dlgInductor.m_strName);
					pInductor->SetFrequence (dlgInductor.m_strFrequence );
					pInductor->SetCompacity (dlgInductor.m_strCompacity );
					pInductor->SetPressure (dlgInductor.m_strPressure );
					pInductor->SetWork(dlgInductor.m_strWork);
					
				}
				else
				{
					//点按了“取消”按钮，不做任何事情
				}
			}
			if (pObject->IsKindOf(RUNTIME_CLASS(CPower)))
			{
				pPower = (CPower *)pObject;
				dlgPower.m_strName = pPower->GetName();
				dlgPower.m_strFirPressure = pPower->GetFirPressure();
				dlgPower.m_strSecPressure = pPower->GetSecPressure ();
				dlgPower.m_strThrPressure = pPower->GetThrPressure ();
				dlgPower.m_strOutPressure = pPower->GetOutPressure ();
				dlgPower.m_strWorkPressure = pPower->GetWorkPressure ();		
				this->UpdateData(FALSE); 				
				if (dlgPower.DoModal() == IDOK)
				{
					this->UpdateData(TRUE);

					pPower->SetName(dlgPower.m_strName);
					pPower->SetFirPressure(dlgPower.m_strFirPressure );
					pPower->SetSecPressure (dlgPower.m_strSecPressure );
					pPower->SetThrPressure (dlgPower.m_strThrPressure );
					pPower->SetOutPressure (dlgPower.m_strOutPressure );
					pPower->SetWorkPressure (dlgPower.m_strWorkPressure );				
					
				}
				else
				{
					//点按了“取消”按钮，不做任何事情