imageeditorview.cpp

在mfc环境下实现的绘图板程序

	{
		m_fZoomScale = fValue;
		UpdateViewSize();
		this->Invalidate();
		((CMainFrame*)this->GetParentFrame())->ShowZoomInfo(m_fZoomScale);		
	}	
}
//------------------鼠标----------------------------------------------------------------
BOOL CImageEditorView::IsPointInCanvas(const CPoint& point)
{
	return (point.x<=m_sizeCanvas.cx && point.y<=m_sizeCanvas.cy);
}

void CImageEditorView::OnLButtonDown(UINT nFlags, CPoint point)
{
	try
	{
	this->SetCapture();
	CClientDC dc(this);
	OnPrepareDC(&dc);
	dc.DPtoLP(&point);

	//改变画布大小
	m_nCanvasHandle = HitCanvasTest(point);
	if (m_nCanvasHandle>=4 && m_nDragHandle<=6)
	{
		m_curMode = smSizeCanvas;						
		SetCursor(CDrawObject::GetHandleCursor(m_nCanvasHandle));
		return;
	}

	if (!IsPointInCanvas(point))
		return;

	switch (m_nCurToolIndex)
	{
	case ID_EDIT_PEN:
		{
			CDrawPen* pDrawObj = new CDrawPen();
			pDrawObj->SetPenStyle(GetColorBar()->m_colorFore,CDrawPen::MyPenStyle::psDot1,m_fZoomScale);
			pDrawObj->m_pointArray.Add(point);			
			ResetCurrentObj(pDrawObj);
			m_curMode = smPenDraw;
			m_ptPrev = point;   
			break;
		}
	case ID_EDIT_BRUSH:
		{
			CDrawPen* pDrawObj = new CDrawPen();			
			pDrawObj->SetPenStyle(GetColorBar()->m_colorFore,m_emBrushStyle,m_fZoomScale);
			pDrawObj->m_pointArray.Add(point);			
			ResetCurrentObj(pDrawObj);
			m_curMode = smPenDraw;
			m_ptPrev = point;   
			break;
		}
	case ID_EDIT_ERASER:
		{
			CDrawPen* pDrawObj = new CDrawPen();
			pDrawObj->SetPenStyle(GetColorBar()->m_colorBack,m_emBrushStyle,m_fZoomScale);
			pDrawObj->m_pointArray.Add(point);			
			ResetCurrentObj(pDrawObj);
			m_curMode = smPenDraw;
			m_ptPrev = point;   
			break;
		}
	case ID_EDIT_LINE:
		{
			CDrawShape* pDrawObj = new CDrawShape(CDrawShape::ShapeType::line);
			pDrawObj->SetShapeStyle(GetColorBar()->m_colorFore,GetColorBar()->m_colorBack, m_emLineWidth, m_emShapeStyle, m_fZoomScale);
			ResetCurrentObj(pDrawObj);
			m_curMode = smShapeDraw;
			break;
		}
	case ID_EDIT_RECTANGLE:
		{
			CDrawShape* pDrawObj = new CDrawShape(CDrawShape::ShapeType::rect);
			pDrawObj->SetShapeStyle(GetColorBar()->m_colorFore,GetColorBar()->m_colorBack, m_emLineWidth, m_emShapeStyle, m_fZoomScale);
			ResetCurrentObj(pDrawObj);
			m_curMode = smShapeDraw;
			break;
		}
	case ID_EDIT_ELLIPSE:
		{
			CDrawShape* pDrawObj = new CDrawShape(CDrawShape::ShapeType::ellipse);
			pDrawObj->SetShapeStyle(GetColorBar()->m_colorFore,GetColorBar()->m_colorBack, m_emLineWidth, m_emShapeStyle, m_fZoomScale);
			ResetCurrentObj(pDrawObj);
			m_curMode = smShapeDraw;
			break;
		}
	case ID_EDIT_ROUND_RECT:
		{
			CDrawShape* pDrawObj = new CDrawShape(CDrawShape::ShapeType::roundrect);
			pDrawObj->SetShapeStyle(GetColorBar()->m_colorFore,GetColorBar()->m_colorBack,m_emLineWidth, m_emShapeStyle, m_fZoomScale);
			ResetCurrentObj(pDrawObj);
			m_curMode = smShapeDraw;
			break;
		}
	case ID_EDIT_SELECT:
		{
			if(m_curMode == smNone)
			{

				CDrawArea* pDrawObj = new CDrawArea(GetColorBar()->m_colorBack);
				ResetCurrentObj(pDrawObj);
				m_curMode = smAreaDraw;
			}
			else if (m_curMode == smSelect)
			{
				CDrawArea* pAreaObj = dynamic_cast<CDrawArea*>(m_pCurObj);
				if (pAreaObj)
				{
					m_nDragHandle = pAreaObj->HitTest(point);
					if (m_nDragHandle>0)
					{
						m_curMode = smSize;						
						SetCursor(pAreaObj->GetHandleCursor(m_nDragHandle));
					}
					else if (pAreaObj->GetBoundRect().PtInRect(point))
					{
						m_curMode = smMove;
					}
					else
					{
						m_bCurrentObjectIsActive = FALSE;
						this->InvalidateObj(pAreaObj);
						if (pAreaObj->IsMoved())
							RecordHistory();

						//m_curMode = smNone;
						CDrawArea* pDrawObj = new CDrawArea(GetColorBar()->m_colorBack);
						ResetCurrentObj(pDrawObj);
						m_curMode = smAreaDraw;						
					}
				}
			}
			m_ptPrev = point; 
			m_ptStart = point;
			return;
			break;
		}
	case ID_EDIT_TEXT:
		{
			
			if(m_curMode == smNone)
			{

				CDrawText* pDrawObj = new CDrawText();
				LOGFONT lf;
				GetColorBar()->m_font.GetLogFont(&lf);
				CSize size(1,1);
				this->ClientToDoc(size);
				lf.lfHeight = lf.lfHeight*size.cx;
				pDrawObj->SetTextStyle(lf,GetColorBar()->m_colorText);
				ResetCurrentObj(pDrawObj);
				m_curMode = smTextDraw;
			}
			else if(m_curMode == smEdit)
			{
				CDrawText* pTextObj = dynamic_cast<CDrawText*>(m_pCurObj);
				if (!m_pCurObj->GetBoundRect().PtInRect(point))
				{
					HidenEditBox();
					m_bCurrentObjectIsActive = TRUE;
					this->InvalidateObj(pTextObj);					
					m_curMode = smSelect;
				}

			}
			else if (m_curMode == smSelect)
			{
				m_nDragHandle = m_pCurObj->HitTest(point);
				if (m_nDragHandle>0)
				{
					m_curMode = smSize;						
					SetCursor(m_pCurObj->GetHandleCursor(m_nDragHandle));
				}
				else if (m_pCurObj->GetBoundRect().PtInRect(point))
				{
					m_curMode = smMove;
				}
				else
				{
					m_bCurrentObjectIsActive = FALSE;
					this->InvalidateObj(m_pCurObj);
					RecordHistory();
					m_curMode = smNone;
				}
			}
			m_ptPrev = point; 
			m_ptStart = point;
			return;
			break;
		}
	case ID_EDIT_FILL:
		{
			//CBrush brush(RGB(0,0,0));
			//CBrush *pOldBrush = dc.SelectObject(&brush);
			//dc.FloodFill(point.x, point.y, GetColorBar()->m_colorFore);
			//dc.SelectObject(pOldBrush);
			//RecordHistory();
			//this->Invalidate();
			m_curMode = smNone;
			return;
		}
	default:
		m_curMode = smNone;
		break;
	}	
	
	m_ptPrev = point; 
	m_ptStart = point; 
	}
	catch(...)
	{
	}
}

void CImageEditorView::OnMouseMove(UINT nFlags, CPoint point)
{

	try
	{
	CClientDC dc(this);
	OnPrepareDC(&dc);
	dc.DPtoLP(&point);	
	((CMainFrame*)this->GetParentFrame())->ShowMousePos(point);	
	int n = HitCanvasTest(point);
	if (n>=4 && n<=6)
	{
		SetCursor(CDrawObject::GetHandleCursor(n));
		if (smNone == m_curMode)
			return;
	}
	//移出画布范围不进行处理
	if (point.x>m_sizeCanvas.cx || point.y>m_sizeCanvas.cy)
	{
		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
		return;
	}

	if ( m_bCurrentObjectIsActive )
	{
		int nDragHandle = m_pCurObj->HitTest(point);
		if (nDragHandle>0)
			SetCursor(m_pCurObj->GetHandleCursor(nDragHandle));
		else if (m_pCurObj->GetBoundRect().PtInRect(point))	
			SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
	}

	if (smNone == m_curMode)
		return;
	
	if (smPenDraw == m_curMode)
	{
		CDrawPen* pPenObj = dynamic_cast<CDrawPen*>(m_pCurObj);
		if (pPenObj)
		{
			this->InvalidateObj(pPenObj);
			pPenObj->m_pointArray.Add(point);
			pPenObj->AdjustBounds();
			this->InvalidateObj(pPenObj);
		}
	}	
	//图形
	else if (smShapeDraw == m_curMode)
	{
		CDrawShape* pShapeObj = dynamic_cast<CDrawShape*>(m_pCurObj);
		if (pShapeObj)
		{
			this->InvalidateObj(pShapeObj);
			pShapeObj->SetBounds(m_ptStart,point);
			this->InvalidateObj(pShapeObj);
		}
	}
	//区域
	else if (smAreaDraw == m_curMode)
	{
		MyDrawFocusRect(m_ptStart,m_ptPrev);
		MyDrawFocusRect(m_ptStart,point);
	}
	//文本
	else if (smTextDraw == m_curMode)
	{
		MyDrawFocusRect(m_ptStart,m_ptPrev);
		MyDrawFocusRect(m_ptStart,point);
	}
	else if (m_bCurrentObjectIsActive && smMove == m_curMode)
	{
		this->InvalidateObj(m_pCurObj);
		CPoint delta = point - m_ptPrev;
		m_pCurObj->OffsetBounds(delta);
		this->InvalidateObj(m_pCurObj);
		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
	}
	else if (m_bCurrentObjectIsActive && smSize == m_curMode )
	{
		this->InvalidateObj(m_pCurObj);
		m_pCurObj->MoveHandleTo(m_nDragHandle, point);
		this->InvalidateObj(m_pCurObj);
		SetCursor(m_pCurObj->GetHandleCursor(m_nDragHandle));
	}
	else if (smSizeCanvas == m_curMode)
	{
		SetCursor(CDrawObject::GetHandleCursor(m_nCanvasHandle));
		switch (m_nCanvasHandle)
		{
		case 4:
			{
				MyDrawFocusRect(CPoint(0,0),CPoint(m_ptPrev.x, m_sizeCanvas.cy));
				MyDrawFocusRect(CPoint(0,0),CPoint(point.x, m_sizeCanvas.cy));
				break;
			}
		case 5:
			{
				MyDrawFocusRect(CPoint(0,0),m_ptPrev);
				MyDrawFocusRect(CPoint(0,0),point);
				break;
			}
		case 6:
			{
				MyDrawFocusRect(CPoint(0,0),CPoint(m_sizeCanvas.cx, m_ptPrev.y));
				MyDrawFocusRect(CPoint(0,0),CPoint(m_sizeCanvas.cx, point.y));
				break;
			}
		default:
			break;
		}

	}
	
	m_ptPrev = point;
	}
	catch(...)
	{
	}

}

void CImageEditorView::OnLButtonUp(UINT nFlags, CPoint point)
{
	try
	{
	ReleaseCapture();
	CClientDC dc(this);	
	OnPrepareDC(&dc);
	CPoint lPoint(point);
	dc.DPtoLP(&lPoint);
	if (smPenDraw == m_curMode)
	{
		CDrawPen* pPenObj = dynamic_cast<CDrawPen*>(m_pCurObj);
		if (IsPointInCanvas(m_ptPrev))
			pPenObj->m_pointArray.Add(lPoint);

		if (pPenObj->m_pointArray.IsEmpty())
		{
			delete m_pCurObj;
			m_pCurObj = NULL;
		}
		else
		{
			pPenObj->AdjustBounds();
			this->InvalidateObj(pPenObj);
			RecordHistory();
		}
		m_curMode = smNone;
	}
	else if (smShapeDraw == m_curMode)
	{
		CDrawShape* pShapeObj = dynamic_cast<CDrawShape*>(m_pCurObj);
		pShapeObj->SetBounds(m_ptStart,lPoint);
		RecordHistory();
		m_curMode = smNone;
	}
	//区域
	else if (smAreaDraw == m_curMode)
	{
		CDrawArea* pAreaObj = dynamic_cast<CDrawArea*>(m_pCurObj);
		
		
		CRect rect(m_ptStart,lPoint);
		rect.NormalizeRect();		
		CSize size(rect.Width()/m_fZoomScale, rect.Height()/m_fZoomScale);
		CPoint ptTopLeft(rect.left/m_fZoomScale, rect.top/m_fZoomScale);
		
		CPoint ptScroll = this->GetScrollPosition();
		dc.LPtoDP(&size);
		dc.LPtoDP(&ptTopLeft);
		ptTopLeft += ptScroll;

		HBITMAP      hBmp;
		CClientDC	dc(this);
		CDC 		memDC;
		CBitmap     bitmap;

		memDC.CreateCompatibleDC(&dc);
		bitmap.CreateCompatibleBitmap(&dc, size.cx, size.cy);
		CBitmap *pOldBitmap = memDC.SelectObject(&bitmap);
		m_imgCurent.StretchBlt(memDC.GetSafeHdc(),
							   0,0,size.cx, size.cy,
							   ptTopLeft.x,ptTopLeft.y,
							   size.cx, size.cy,
							   SRCCOPY);
		
		hBmp=(HBITMAP)bitmap.GetSafeHandle();	
		memDC.SelectObject(pOldBitmap);
		bitmap.Detach();

		if (hBmp)
			pAreaObj->SetOrigArea(m_ptStart,lPoint,hBmp);

		m_bCurrentObjectIsActive = TRUE;
		this->InvalidateObj(pAreaObj);
		m_curMode = smSelect;
		return;
	}
	else if (smTextDraw == m_curMode)
	{
		CRect rect(m_ptStart,lPoint);
		rect.NormalizeRect();
		m_pCurObj->SetBounds(m_ptStart,lPoint);
		this->ShowEditBox(rect);
		m_curMode = smEdit;
		return;
	}
	else if (m_curMode == smMove || m_curMode == smSize)
	{
		m_curMode = smSelect;
	}
	else if (m_curMode == smSizeCanvas)
	{
		switch (m_nCanvasHandle)
		{
		case 4:
			{
				m_sizeCanvas.cx = lPoint.x;
				break;
			}
		case 5:
			{
				m_sizeCanvas.cx = lPoint.x;
				m_sizeCanvas.cy = lPoint.y;
				break;
			}
		case 6:
			{
				m_sizeCanvas.cy = lPoint.y;
				break;
			}
		default:
			break;
		}
		RecordHistory();
		this->Invalidate();
		m_curMode = smNone;
	}
	}
	catch(...)
	{
	}	
}
void CImageEditorView::OnLButtonDblClk(UINT nFlags, CPoint point)
{	
	CDrawText* pTextObj = dynamic_cast<CDrawText*>(m_pCurObj);
	this->ClientToDoc(point);
	if (pTextObj!=NULL && pTextObj->GetBoundRect().PtInRect(point))
	{
		this->ShowEditBox(pTextObj->GetBoundRect(),pTextObj->m_strText);
		m_bCurrentObjectIsActive = FALSE;
		m_curMode = smEdit;
	}
	
}
void CImageEditorView::HidenEditBox(void)
{
	if (m_pEditBox &&(m_pEditBox->GetStyle() & WS_VISIBLE) != 0) 
	{
		m_pEditBox->ModifyStyle(WS_VISIBLE,NULL);
		CString strTemp;
		m_pEditBox->GetWindowText(strTemp);
		CDrawText* pTextObj = dynamic_cast<CDrawText*>(m_pCurObj);
		if (pTextObj!=NULL)
		{
			pTextObj->SetText(strTemp);
		}
	}
}
void CImageEditorView::InvalidateObj(CDrawObject* pObj)
{
	CRect rect = pObj->GetBoundRect();
	CRect rectCanvas(CPoint(0,0),m_sizeCanvas);
	rect.NormalizeRect();
	if (rect.IntersectRect(rect,rectCanvas))
	{		
		this->DocToClient(rect);
		rect.InflateRect(10,10);
		this->InvalidateRect(rect,FALSE);
	}
}
void CImageEditorView::ResetCurrentObj(CDrawObject* pNewObj)
{
	if (m_pCurObj!=NULL)
		delete m_pCurObj;
	m_pCurObj = pNewObj;
	
	if (pNewObj==NULL)