张明奇（卡哥）注释：成功版本

        MFC文档/视图的应用程序，向导给了打印及打印预览的标准支持。使这类应用程序打印及打印预览工作得以简化。另一类对话框程序却没有相应支持，从MFC打印及打印预览的标准支持入手，可以在对话框程序中，增加三个类以支持打印及打印预览，本文介绍了这三个类的实现。

        打印及打印预览是编写应用程序经常要解决的问题，为了理解VC++对话框程序的打印及打印预览实现,要先掌握基于文档/视图的应用程序打印及打印预览的基本原理。所以分为两部分介绍。

一、基于文档/视图的应用程序的打印及打印预览原理

        VC++基于文档/视图的应用程序中用MFC应用程序向导在步骤4对话框中选中Print and Print Preview选项，可以包含基本打印及打印预览的支持，应用程序文件菜单中会生成两个菜单项分别是打印（标识符ID_FILE_PRINT）和打印预览(标识符：ID_FILE_PRINT_PREVIEW)，展开程序源代码，可以发现，是Cview类提供标准打印和打印预览菜单命令的消息处理函数：

        设应用程序视图类为CMyView,展开MyView.cpp,其消息映象部分有如下两行：

ON_COMMAND(ID_FILE_PRINT,CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW,CView::OnFilePrintPreview)

CView::OnFilePrint 和CView::OnFilePrintPreview函数都进行打印操作，但View::OnFilePrint将实际发送到打印机，而CView::OnFilePrintPreview则将输出发送到程序窗口上方显示的预览窗口显示一个或两个打印页面的复制外观。利用上面加入的缺省打印支持，只能打印或预览图形的一个打印页面，一个页中放不下的部分则放弃，为了加强程序，使它打印整个图形，一页中放不下的部分放在另一页，可以通过覆盖几个打印期间调用的虚拟函数来完成。下图说明了整个打印和打印预览的过程，显示了每个虚拟函数在程序中哪个部分调用。注意每打印一个页面就要经历图中的一个循环。

 

下表列出了虚拟函数并介绍了各自完成的任务，由于MFC打印或打印预览文档时都调用虚拟函数，所以定义的覆盖函数既影响打印也影响打印预览。

二、对话框程序打印及打印预览的实现

        以上是基于文档/视图的应用程序的打印原理，可以根据需要从CView类派生出视图类覆盖打印及打印预览过程中的CView类的虚拟函数来定制文档/视图应用程序的打印及打印预览。在实际中，有很多基于对话框的应用程序，也需要提供打印及打印预览。但向导没有给基于对话框应用程序的基本支持。有了以上知识，可以构造出无文档的视图类，具体的实现时，增加三个类，用以支持打印及打印预览。以下用一具体实例说明。
 

函数名()	覆盖函数可能完成的任务
CView::OnPreparePrinting()	调用CprintInfo成员函数（如CprintInfo::SetMaxPage设置文档长度）或设置CprintInfo数据成员以影响Print对话框或打印预览操作，然后调用DoPreparePrinting生成用于打印或打印预览的设备描述表（注意必须覆盖OnPreparePrinting并调用DoPreparePrinting） ---------------------  作者：卡哥  来源：CSDN  原文：https://blog.csdn.net/L_Andy/article/details/8071768  版权声明：本文为博主原创文章，转载请附上博文链接！
CView::OnBeginPrinting()	分配专门用于打印的字体，画笔、画刷和其它对象，根据设备描述表计算并设置文档长，在设备描述表上存放所需的消息（这是第一个访问设备描述表的的虚拟函数）
CView::OnPrepareDC()	设置打印当前页面的文本或图形属性，修改视图原点，以打印当前页面，如果没有设置文档长度，在文档末尾终止打印循环（CprintInfo::m_bContinuePrinting赋值FALSE）
CView::OnPrint()	调用OnDraw进行输出；调用OnDraw前选择OnBeginPrinting分配的字体，调用OnDraw后取消对象，打印只出现在文档打印版中的页头和页脚，如果打印输出与屏幕输出的外观不同， 在这里打印，而不是调用OnDraw
CView::OnEndPrinting()	调用Cgdi::DeleteObject删除OnBeginPrinting分配的对象

 1.用MFC应用向导创建对话框应用程序，设主对话框类为CPrintPreviewDlg，在主对话框上放一按钮，（标题：打印预览，ID：IDC_PRINTPREVIEW_BUTTON），用类向导增加其BN_CLICKED的消息响应函数OnPrintPreviewButton生成打印预览界面
 

void CPrintPreviewDlg::OnPrintPreviewButton()
{
    CPrintFrame* pf = new CPrintFrame(this);
}

      2、增加新类：

用ClassWizard新建CPrintFrame类（基类CFrameWnd）,功能上相当于文档/视图的应用程序的框架窗口类。
用ClassWizard新建CPrintView类（基类CScrollView）,功能上相当于文档/视图的应用程序的视图类。
增加CPrintPreviewView类（基类CPreviewView,注意在头其定义头文件中加入包含afxpriv.h),用于打印预览界面的视图类。

        3、对新生成的各类修改如下：

CPrintFrame类：

①增加公有数据成员

CPrintPreviewDlg*    m_pOldWnd;        // 用于保存主对话框对象；
CPrintView*              m_pView;              // 用于保存视图类对象；

②重载构造函数，保存对主对话框对象指针，创建窗口

CPrintFrame::CPrintFrame(CPrintPreviewDlg* pOld)
{
    m_pOldWnd = pOld;
    if ( !Create(NULL, "打印预览", WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, CRect(200, 200, 500, 500)))
        TRACE0("Failed to create view window! \n");
}

③修改析构函数，让主对话框显示'

CPrintFrame::~CPrintFrame()
{
    m_pOldWnd->ShowWindow(SW_SHOW);
}

④添加打印模式函数，设置A4纸纵向打印或横向打印(可以选择使用)

#define   DMORIENT_PORTRAIT                           1       //纵向  
#define   DMORIENT_LANDSCAPE                        2       //横向

void SetLandscapeMode(int   PrintMode)  
{   
    PRINTDLG   pd;   
    pd.lStructSize=(DWORD)sizeof(PRINTDLG);   
    BOOL   bRet=AfxGetApp()->GetPrinterDeviceDefaults(&pd);   
    if(bRet)   
    {   
        //   protect   memory   handle   with   ::GlobalLock   and   ::GlobalUnlock  
        DEVMODE   FAR   *pDevMode=(DEVMODE   FAR   *)::GlobalLock(pd.hDevMode);
        pDevMode->dmPaperSize=DMPAPER_A4;   //将打印纸设置为A4   
        //   set   orientation   to   landscape   
        if(PrintMode==1)     //纵向打印   
            pDevMode->dmOrientation = DMORIENT_PORTRAIT;   
        else   if(PrintMode==2)    //横向打印   
            pDevMode->dmOrientation = DMORIENT_LANDSCAPE;       
        ::GlobalUnlock(pd.hDevMode);   
    }   
}  

⑤用ClassWizard增加WM_Create消息处理函数,关联CPrintView视图对象；调用其OnFilePrintPreview函数进行打印预览（若要直接打印，可直接向其发送消息）；隐藏主对话框。

nt CPrintFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
        return -1;
 
        // TODO: Add your specialized creation code here
        CCreateContext context;
        context.m_pNewViewClass = RUNTIME_CLASS(CPrintView);
        context.m_pCurrentFrame = this;
        context.m_pCurrentDoc = NULL;
        context.m_pLastView = NULL;
        m_pView = STATIC_DOWNCAST(CPrintView, CreateView(&context));
 
        if (m_pView != NULL)
        {
            m_pView->ShowWindow(SW_SHOW);
            SetActiveView(m_pView);
       //   SetLandscapeMode(DMORIENT_LANDSCAPE);
        }

        SetIcon(m_pOldWnd->GetIcon(FALSE), FALSE);
        SetIcon(m_pOldWnd->GetIcon(TRUE), TRUE);
        ShowWindow(SW_MAXIMIZE);
        CWinApp *pApp = AfxGetApp();
        pApp->m_pMainWnd = this;
        m_pView->OnFilePrintPreview();
        // m_pView->SendMessage(WM_COMMAND, ID_FILE_PRINT);  // 直接打印
        m_pOldWnd->ShowWindow(SW_HIDE);
 
        return 0;
}

⑥添加WM_Close消息处理函数

void CPrintFrame::OnClose()
{
    // TODO: Add your message handler code here and/or call default
    CPrintFrame* pf=(CPrintFrame*)::AfxGetMainWnd(); 
    CWinApp *pApp=AfxGetApp();
    pApp->m_pMainWnd = pf->m_pOldWnd; 
    pf->DestroyWindow();
    // CFrameWnd::OnClose();
}

CPrintView类：

①修改构造函数：将坐标射模式置为缺省模式。

CPrintView::CPrintView()

{
    m_nMapMode = MM_TEXT;

}

②增加消息映射实现打印。

ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)

③重载虚函数OnPreparePrinting，调用DoPreparePrinting生成用于打印或打印预览的设备描述表。

BOOL CPrintView::OnPreparePrinting(CPrintInfo* pInfo)
{
    // TODO: call DoPreparePrinting to invoke the Print dialog box
    //pInfo->SetMaxPage(1);
    return DoPreparePrinting(pInfo);
    // return CLogScrollView::OnPreparePrinting(pInfo);
}

 

④增加公有函数OnFilePrintPreview，调用DoPrintPreview实现打印预览，该函数需要传入四个参数：打印预览工具条资源ID，执行打印及打印预览的视图对象指针，打印预览界面视图类的 CRuntimeClass指针，打印预览状态类CPrintPreviewState对象指针。
 

void CPrintView::OnFilePrintPreview()
{
    CPrintPreviewState* pState = new CPrintPreviewState;
    pState->lpfnCloseProc = _AfxPrintPreviewCloseProc; //设置打印预览窗口关闭时的调用函数
    if (!DoPrintPreview(AFX_IDD_PREVIEW_TOOLBAR, this, RUNTIME_CLASS(CPrintPreviewView), pState))
    {
        TRACE0("Error, DoPrintPreview failed. \n");
        AfxMessageBox(AFX_IDP_COMMAND_FAILURE);
        delete pState;
    }
}

⑤一些其他函数的实现

void CPrintView::OnInitialUpdate()
{

 CScrollView::OnInitialUpdate();

 CSize sizeTotal;
 // TODO: 计算此视图的合计大小
 sizeTotal.cx = sizeTotal.cy = 100;
 SetScrollSizes(MM_TEXT, sizeTotal);

}

void CPrintView::OnDraw(CDC* pDC)
{
    CDocument* pDoc = GetDocument();
    // TODO: add draw code here
}

void CPrintView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
{
    // m_rectPrint = pInfo->m_rectDraw; 

    //进行打印的内容代码等；
    CLogScrollView::OnPrint(pDC, pInfo);
}

⑥在PrintView.cpp文件中增加全局函数，_AfxMyPreviewCloseProc，当单击打印预览窗口关闭按钮时被调用。

BOOL CALLBACK _AfxPrintPreviewCloseProc(CFrameWnd* pFrameWnd)
{
    ASSERT_VALID(pFrameWnd);
    CPrintPreviewView* pView = (CPrintPreviewView*)pFrameWnd->GetDlgItem(AFX_IDW_PANE_FIRST);
    ASSERT_KINDOF(CPreviewView, pView);
    pView->OnPreviewClose();
    return FALSE;
}

CPrintPreviewView类：

手动添加类CPrintPreviewView继承CPreviewView类，.h文件如下~

#pragma once
#include "afxpriv.h"

#if !defined(AFX_MYPREVIEWVIEW_H__0AE8B670_B1AE_11DA_812E_00E04C39032F__INCLUDED_)

#define AFX_MYPREVIEWVIEW_H__0AE8B670_B1AE_11DA_812E_00E04C39032F__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <afxpriv.h>
class CMyPreviewView : public CPreviewView 
{
 DECLARE_DYNCREATE(CMyPreviewView)
public:
 afx_msg void OnPreviewClose();
protected:
 CMyPreviewView();
 virtual ~CMyPreviewView();
 void OnDraw(CDC* pDC);
 void OnEndPrintPreview(CDC* pDC, CPrintInfo* pInfo, POINT point, CPreviewView* pView);
 afx_msg void OnPreviewPrint( );
 DECLARE_MESSAGE_MAP( )
};

#endif // !defined(AFX_MYPREVIEWVIEW_H__0AE8B670_B1AE_11DA_812E_00E04C39032F__INCLUDED_)

增加工具栏按钮的消息响应函数OnPreviewClose()，OnPreviewPrint() .cpp如下详尽代码

#include "stdafx.h"
#include ".\mypreviewview.h"
#include "StatisticsCoverDlg.h"
#include ".\statisticscoverdlg.h"
#include  "PrintFrame.h"
//#ifdef _DEBUG
//#undef THIS_FILE
//static char THIS_FILE［］=__FILE__;
//#define new DEBUG_NEW
//#endif

//

IMPLEMENT_DYNCREATE(CMyPreviewView, CPreviewView)

CMyPreviewView::CMyPreviewView()
{

}
CMyPreviewView::~CMyPreviewView()
{

}
BEGIN_MESSAGE_MAP(CMyPreviewView, CPreviewView)

 ON_COMMAND(AFX_ID_PREVIEW_CLOSE, OnPreviewClose)
 ON_COMMAND(AFX_ID_PREVIEW_PRINT, OnPreviewPrint)

END_MESSAGE_MAP()

void CMyPreviewView::OnDraw(CDC *pDC)
{
 CPreviewView::OnDraw(pDC);

 m_pToolBar->PostMessage(WM_IDLEUPDATECMDUI, (WPARAM)TRUE);// 控制条的命令状态更新
}

void CMyPreviewView::OnEndPrintPreview(CDC* pDC, CPrintInfo* pInfo, POINT point, CPreviewView* pView)
{
 CPreviewView::OnEndPrintPreview(pDC, pInfo, point, pView);
}

void CMyPreviewView::OnPreviewClose()
{
 CPrintFrame* pf=(CPrintFrame*)::AfxGetMainWnd();
 CWinApp *pApp=AfxGetApp();    
 pApp->m_pMainWnd=pf->m_pOldWnd;
 pf->DestroyWindow();
}

void CMyPreviewView::OnPreviewPrint()
{
 m_pPrintView->SendMessage(WM_COMMAND, ID_FILE_PRINT);

}

        至此，基于对话框应用程序的具有打印及打印预览的基本支持已经生成，完全由新生成的三个类来支持。正如上一部分介绍的，可以在CMyView类中定义CView类的几个在打印过程中虚拟函数（CView::OnPreparePrinting，CView::OnBeginPrinting，CView::OnPrepareDC，CView::OnPrint，CView::OnEndPrinting，具体内容可参见前一部分）来定制其打印或打印预览的内容。也可以将实现打印或打印预览新增的三个类，生成MFC扩展动态链接库，以方便加入到程序中。
        打完收功~~
 

大家在使用网站下载的一些MFC程序时，经常会遇见一个报错问题：【error C3861: “AfxMessageBox”: 找不到标识符】，因为我是个菜鸟，所以一直被这个问题所困扰。网上搜索过各种各样的解决方法，发现这类问题的解决方法比较混乱，也没人能说出个具体的原因。

一般搜索这个问题，第一项即是MSDN社区的回答：点击打开链接

此处解决方法很简单，就是将程序中的AfxMessageBox函数全部替换成为MessageBox函数，因为前者调用的是MFC的底层函数库，后者调用的是最为基本的Win32 API。故绝对不会出现“找不到标识符”的错误。

问题虽然可以解决，但是却十分麻烦。而且，相信很多人跟笔者的疑惑是一样的：我明明就是要运行MFC程序，为什么会不支持MFC的底层函数库？

于是，笔者继续寻找有没有其他的解决方法，例如网上常说的在头文件里面加入#include<afxwin.h>或者#include<stdafx.h>（其实两者是一样的，因为stdafx.h也调用了afxwin.h，而afxwin.h里面标识了函数AfxMessageBox），还是没有成功。

同样，我也想过把程序就当做是WIN32程序，再进行手工转换成MFC程序。于是又搜索了这样那样的办法……结果也都是一样的，还是不成功。

最后，我想不行我自己编写一个AfxMessageBox函数总行了吧！不然每次都要改来改去实在太麻烦了。然后我打开了AfxMessageBox函数所在的头文件afxwin.h，使用VS平台进行搜索，于是我就看到了这个……

不知道为啥AfxMessageBox函数竟然被注释掉了，算是彻底无语了……于是就把这四行恢复，再运行，OK，搞定！

转载自  http://www.xuebuyuan.com/1578921.html

#pragma once
#include "atltypes.h"
#include "afxwin.h"
enum ShapType
{
	knone = 0,
	kLine,
	kCircle,
	kEllip,
	kRect
};

class CSharp
{
public:
	int m_nLineWidth;
	int m_nLineType;
	COLORREF m_color;
	virtual void Draw(CDC* du) = 0;
	virtual ShapType type() { return knone; }
};

class Cline : public CSharp
{
public:
	Cline() 
	{

	}

	Cline(CPoint& pts, CPoint& pte, int& LinWidth, int& LineType, COLORREF color)
	{
		m_ptS = pts;
		m_ptE = pte;
		m_nLineWidth = LinWidth;
		m_nLineType = LineType;
		m_color = color;
	}
public:
	CPoint m_ptS;
	CPoint m_ptE;
	virtual void Draw(CDC* du);
	virtual ShapType type() { return kLine; };
};
class CCircle : public CSharp
{
public:
	CCircle()
	{

	}
	CCircle(CPoint& pts, CPoint& pte, int& LinWidth, int& LineType, COLORREF color)
	{
		m_ptCenter.x = (pts.x + pte.x) / 2;
		m_ptCenter.y = (pts.y + pte.y) / 2;
		m_iRadius = 100;
		m_nLineWidth = LinWidth;
		m_nLineType = LineType;
		m_color = color;
	}
public:
	CPoint m_ptCenter;
	int m_iRadius;
	virtual void Draw(CDC* du);
	virtual ShapType type() { return kLine; };
};
class CEllipse : public CSharp
{
public:
	CEllipse()
	{

	}
	CEllipse(CPoint& pts, CPoint& pte, int& LinWidth, int& LineType, COLORREF color)
	{
		m_ptS = pts;
		m_ptE = pte;
		m_nLineWidth = LinWidth;
		m_nLineType = LineType;
		m_color = color;
	}
public:
	CPoint m_ptS;
	CPoint m_ptE;
	virtual void Draw(CDC* du);
	virtual ShapType type() { return kEllip; };
};
class Rectangle1 : public CSharp
{
public:
	Rectangle1()
	{

	}

	Rectangle1(CPoint& pts, CPoint& pte, int& LinWidth, int& LineType, COLORREF color)
	{
		m_ptS = pts;
		m_ptE = pte;
		m_nLineWidth = LinWidth;
		m_nLineType = LineType;
		m_color = color;
	}
public:
	CPoint m_ptS;
	CPoint m_ptE;
	virtual void Draw(CDC* du);
	virtual ShapType type() { return kRect; };
};

CArchive& operator <<(CArchive& s, CSharp& shap);
CArchive& operator >>(CArchive& s, CSharp& shap);
CArchive& operator <<(CArchive& s, Cline& line);
CArchive& operator >>(CArchive& s, Cline& line);

CArchive& operator <<(CArchive& s, CCircle& circle);
CArchive& operator >>(CArchive& s, CCircle& circle);

CArchive& operator <<(CArchive& s, CEllipse& ellipse);
CArchive& operator >>(CArchive& s, CEllipse& ellipse);

CArchive& operator <<(CArchive& s, Rectangle1& rectangle);
CArchive& operator >>(CArchive& s, Rectangle1& rectangle);

#include "pch.h"
#include "atltypes.h"
#include "afxwin.h"
#include "CSharp.h"



void Cline::Draw(CDC* du)
{
    CPen cPen;
    cPen.CreatePen(m_nLineType,m_nLineWidth, m_color);
    du->SelectObject(&cPen);
    du->MoveTo(m_ptS);
    du->LineTo(m_ptE);
};
void CCircle::Draw(CDC* du)
{
    CPen cPen;
    cPen.CreatePen(m_nLineType, m_nLineWidth, m_color);
    du->SelectObject(&cPen);
    du->Arc(m_ptCenter.x - m_iRadius, m_ptCenter.y - m_iRadius, m_ptCenter.x + m_iRadius, m_ptCenter.y + m_iRadius, 0, 0, 0, 0);
};
void CEllipse::Draw(CDC* du)
{
    CPen cPen;
    cPen.CreatePen(m_nLineType, m_nLineWidth, m_color);
    du->SelectObject(&cPen);
    du->Ellipse(m_ptS.x, m_ptS.y, m_ptE.x, m_ptE.y);
};
void Rectangle1::Draw(CDC* du)
{
    CPen cPen;
    cPen.CreatePen(m_nLineType, m_nLineWidth, m_color);
    du->SelectObject(&cPen);
    du->Rectangle(CRect(m_ptS, m_ptE));
};

CArchive& operator <<(CArchive& s, CSharp& shap)
{
	s << shap.m_nLineType << shap.m_nLineWidth << shap.m_color;
	return s;
}
CArchive& operator >>(CArchive& s, CSharp& shap)
{
	s >> shap.m_nLineType >> shap.m_nLineWidth >> shap.m_color;
	return s;
}

CArchive& operator <<(CArchive& s, Cline& line)
{
	s << (CSharp&)line;
	s << line.m_ptS << line.m_ptE;
	return s;
}
CArchive& operator >>(CArchive& s, Cline& line)
{
	s >> (CSharp&)line;
	s >> line.m_ptS >> line.m_ptE;
	return s;
}

CArchive& operator <<(CArchive& s, CCircle& circle)
{
	s << (CSharp&)circle;
	s << circle.m_ptCenter << circle.m_iRadius;
	return s;
}
CArchive& operator >>(CArchive& s, CCircle& circle)
{
	s >> (CSharp&)circle;
	s >> circle.m_ptCenter >> circle.m_iRadius;
	return s;
}

CArchive& operator <<(CArchive& s, CEllipse& ellipse)
{
	s << (CSharp&)ellipse;
	s << ellipse.m_ptS << ellipse.m_ptE;
	return s;
}
CArchive& operator >>(CArchive& s, CEllipse& ellipse)
{
	s >> (CSharp&)ellipse;
	s >> ellipse.m_ptS >> ellipse.m_ptE;
	return s;
}

CArchive& operator <<(CArchive& s, Rectangle1& rectangle)
{
	s << (CSharp&)rectangle;
	s << rectangle.m_ptS << rectangle.m_ptE;
	return s;
}
CArchive& operator >>(CArchive& s, Rectangle1& rectangle)
{
	s >> (CSharp&)rectangle;
	s >> rectangle.m_ptS >> rectangle.m_ptE;
	return s;
}

#pragma once


// GraphicAttribute 对话框

class GraphicAttribute : public CDialogEx
{
	DECLARE_DYNAMIC(GraphicAttribute)

public:
	GraphicAttribute(CWnd* pParent = nullptr);   // 标准构造函数
	virtual ~GraphicAttribute();

// 对话框数据
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_DIALOG_GraphicAttribute };
#endif

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

	DECLARE_MESSAGE_MAP()
public:
	COLORREF m_color;
	int m_nLineWidth;
	int m_nLineType;
	afx_msg void OnBnClickedButtonColor();
	afx_msg void OnBnClickedOk();
};

// GraphicAttribute.cpp: 实现文件
//

#include "pch.h"
#include "TaskOne.h"
#include "GraphicAttribute.h"
#include "afxdialogex.h"


// GraphicAttribute 对话框

IMPLEMENT_DYNAMIC(GraphicAttribute, CDialogEx)

GraphicAttribute::GraphicAttribute(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_DIALOG_GraphicAttribute, pParent)
	, m_color(0)
	, m_nLineWidth(0)
	, m_nLineType(0)
{

}

GraphicAttribute::~GraphicAttribute()
{
}

void GraphicAttribute::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT_LineWidth, m_nLineWidth);
	DDX_Text(pDX, IDC_EDIT_LineType, m_nLineType);
}


BEGIN_MESSAGE_MAP(GraphicAttribute, CDialogEx)
	ON_BN_CLICKED(IDC_BUTTON_Color, &GraphicAttribute::OnBnClickedButtonColor)
	ON_BN_CLICKED(IDOK, &GraphicAttribute::OnBnClickedOk)
END_MESSAGE_MAP()


// GraphicAttribute 消息处理程序


void GraphicAttribute::OnBnClickedButtonColor()
{
	// TODO: 在此添加控件通知处理程序代码
	CMFCColorDialog dlg;
	if (dlg.DoModal() != IDOK)
		return;
	m_color = dlg.GetColor();
}


void GraphicAttribute::OnBnClickedOk()
{
	// TODO: 在此添加控件通知处理程序代码
	CDialogEx::OnOK();
	CString str;
	GetDlgItem(IDC_EDIT_LineType)->GetWindowText(str);
	m_nLineType = _ttoi(str);

	GetDlgItem(IDC_EDIT_LineWidth)->GetWindowText(str);
	m_nLineWidth = _ttoi(str);
}

// TaskOneView.h: CTaskOneView 类的接口
//

#pragma once
#include "MainFrm.h"

class CTaskOneView : public CView
{
protected: // 仅从序列化创建
	CTaskOneView() noexcept;
	DECLARE_DYNCREATE(CTaskOneView)

// 特性
public:
	CTaskOneDoc* GetDocument() const;

// 操作
public:
	CPoint m_point1;
	CPoint m_point2;
	bool m_bSaveTag ;   //判断图像是否是第一次存储
	int m_nLineType1;   //线型
	int m_nLineWidth1 ;  //线宽
	COLORREF m_color1;   //颜色 
	CString m_strSaveFilePath;
	CPoint m_SavePoint[100];
	int m_nDraw = 0;      //1,2,3,4分别表示画线，圆，椭圆，矩形
	CMainFrame* mainFrm;
	
// 重写
public:
	virtual void OnDraw(CDC* pDC);  // 重写以绘制该视图
	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
	virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
	virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
	virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);

// 实现
public:
	virtual ~CTaskOneView();
#ifdef _DEBUG
	virtual void AssertValid() const;
	virtual void Dump(CDumpContext& dc) const;
#endif

protected:

// 生成的消息映射函数
protected:
	afx_msg void OnFilePrintPreview();
	afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
	afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
	DECLARE_MESSAGE_MAP()
public:
	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
	afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
	afx_msg void OnLine();
	afx_msg void OnCircle();
	afx_msg void OnEllipse();
	afx_msg void OnRectangle();
	
	afx_msg void OnColor();
	afx_msg void OnLinewidth();
	afx_msg void OnLinetype();
	afx_msg void OnGraphicattribute();
};

#ifndef _DEBUG  // TaskOneView.cpp 中的调试版本
inline CTaskOneDoc* CTaskOneView::GetDocument() const
   { return reinterpret_cast<CTaskOneDoc*>(m_pDocument); }
#endif

// TaskOneView.cpp: CTaskOneView 类的实现
//

#include "pch.h"
#include "framework.h"
// SHARED_HANDLERS 可以在实现预览、缩略图和搜索筛选器句柄的
// ATL 项目中进行定义，并允许与该项目共享文档代码。
#ifndef SHARED_HANDLERS
#include "TaskOne.h"
#endif

#include "TaskOneDoc.h"
#include "TaskOneView.h"
#include "CSharp.h"
#include "GraphicAttribute.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CTaskOneView

IMPLEMENT_DYNCREATE(CTaskOneView, CView)

BEGIN_MESSAGE_MAP(CTaskOneView, CView)
	// 标准打印命令
	ON_COMMAND(ID_FILE_PRINT, &CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, &CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, &CTaskOneView::OnFilePrintPreview)
	ON_WM_CONTEXTMENU()
	ON_WM_RBUTTONUP()
	
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
    ON_COMMAND(ID_LINE, &CTaskOneView::OnLine)
	ON_COMMAND(ID_Circle, &CTaskOneView::OnCircle)
	ON_COMMAND(ID_Ellipse, &CTaskOneView::OnEllipse)
    ON_COMMAND(ID_Rectangle, &CTaskOneView::OnRectangle)
    ON_COMMAND(ID_GraphicAttribute, &CTaskOneView::OnGraphicattribute)
END_MESSAGE_MAP()

// CTaskOneView 构造/析构

CTaskOneView::CTaskOneView() noexcept
{
	// TODO: 在此处添加构造代码
     m_bSaveTag = 0; 
     m_color1 = RGB(0, 0, 0);
     m_nLineWidth1 = 0;
     m_nDraw = -1;
     m_nLineType1 = 0;
}

CTaskOneView::~CTaskOneView()
{
}

BOOL CTaskOneView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: 在此处通过修改
	//  CREATESTRUCT cs 来修改窗口类或样式

	return CView::PreCreateWindow(cs);
}

// CTaskOneView 绘图

void CTaskOneView::OnDraw(CDC* pDC)
{
	CTaskOneDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	if (!pDoc)
		return;

	// TODO: 在此处为本机数据添加绘制代码
	auto shaps = pDoc->m_vecShap;
	int length = pDoc->m_vecShap.size();
	for (int i = 0; i < length; i++)
	{
        pDoc->m_vecShap[i]->Draw(pDC);
	}
}






// CTaskOneView 打印


void CTaskOneView::OnFilePrintPreview()
{
#ifndef SHARED_HANDLERS
	AFXPrintPreview(this);
#endif
}

BOOL CTaskOneView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// 默认准备
	return DoPreparePrinting(pInfo);
}

void CTaskOneView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: 添加额外的打印前进行的初始化过程
}

void CTaskOneView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: 添加打印后进行的清理过程
}

void CTaskOneView::OnRButtonUp(UINT /* nFlags */, CPoint point)
{
	ClientToScreen(&point);

	OnContextMenu(this, point);
}

void CTaskOneView::OnContextMenu(CWnd* /* pWnd */, CPoint point)
{
#ifndef SHARED_HANDLERS
	theApp.GetContextMenuManager()->ShowPopupMenu(IDR_POPUP_EDIT, point.x, point.y, this, TRUE);
#endif
}


// CTaskOneView 诊断

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

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

CTaskOneDoc* CTaskOneView::GetDocument() const // 非调试版本是内联的
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTaskOneDoc)));
	return (CTaskOneDoc*)m_pDocument;
}
#endif //_DEBUG


// CTaskOneView 消息处理程序


void CTaskOneView::OnLine()
{
	// TODO: 在此添加命令处理程序代码
    m_nDraw = 1;
}

void CTaskOneView::OnCircle()
{
	// TODO: 在此添加命令处理程序代码
    m_nDraw = 2;
}

void CTaskOneView::OnEllipse()
{
	// TODO: 在此添加命令处理程序代码
    m_nDraw = 3;
}

void CTaskOneView::OnRectangle()    
{
    // TODO: 在此添加命令处理程序代码
    m_nDraw = 4;
}


void CTaskOneView::OnLButtonDown(UINT nFlags, CPoint point)
{
    // TODO: 在此添加消息处理程序代码和/或调用默认值
    CView::OnLButtonDown(nFlags, point);
    m_point1 = point;
}

void CTaskOneView::OnLButtonUp(UINT nFlags, CPoint point)
{
    CDC* pDc = GetDC();
    // TODO: 在此添加消息处理程序代码和/或调用默认值
    CView::OnLButtonUp(nFlags, point);
    m_point2 = point;

    CSharp* pShrp = NULL;
    if (m_nDraw == 1)
    {
        pShrp = new Cline(m_point1, m_point2, m_nLineWidth1, m_nLineType1, m_color1);
        pShrp->Draw(pDc);
    }
    else if (m_nDraw == 2)
    {
        pShrp = new CCircle(m_point1, m_point2, m_nLineWidth1, m_nLineType1, m_color1);
        pShrp->Draw(pDc);
    }
    else if (m_nDraw == 3)
    {
        pShrp = new CEllipse(m_point1, m_point2, m_nLineWidth1, m_nLineType1, m_color1);
        pShrp->Draw(pDc);
    }
    else if (m_nDraw == 4)
    {
        pShrp = new Rectangle1(m_point1, m_point2, m_nLineWidth1, m_nLineType1, m_color1);
        pShrp->Draw(pDc);
    }
    else
    {
        return;
    }
    CTaskOneDoc* pDoc = GetDocument();
    pDoc->AddShap(pShrp);

    ::ReleaseDC(m_hWnd,*pDc);
    pDc = NULL;
    m_nDraw = -1;
}




void CTaskOneView::OnGraphicattribute()
{
    // TODO: 在此添加命令处理程序代码
    GraphicAttribute CSel;
    if (CSel.DoModal() != IDOK)
        return;
    m_color1 = CSel.m_color;
    m_nLineWidth1 = CSel.m_nLineWidth;
    m_nLineType1 = CSel.m_nLineType;
}

// TaskOneDoc.h: CTaskOneDoc 类的接口
//


#pragma once
#include<vector>
#include "CSharp.h"




class CTaskOneDoc : public CDocument
{
protected: // 仅从序列化创建
	CTaskOneDoc() noexcept;
	DECLARE_DYNCREATE(CTaskOneDoc)

// 特性
public:

// 操作
public:

// 重写
public:
	virtual BOOL OnNewDocument();
	virtual void Serialize(CArchive& ar);
#ifdef SHARED_HANDLERS
	virtual void InitializeSearchContent();
	virtual void OnDrawThumbnail(CDC& dc, LPRECT lprcBounds);
#endif // SHARED_HANDLERS

// 实现
public:
	virtual ~CTaskOneDoc();
#ifdef _DEBUG
	virtual void AssertValid() const;
	virtual void Dump(CDumpContext& dc) const;
#endif
	void AddShap(CSharp* pShap);

protected:

// 生成的消息映射函数
protected:
	DECLARE_MESSAGE_MAP()

public:
	std::vector<CSharp*> m_vecShap;
	

#ifdef SHARED_HANDLERS
	// 用于为搜索处理程序设置搜索内容的 Helper 函数
	void SetSearchContent(const CString& value);
#endif // SHARED_HANDLERS
};

// TaskOneDoc.cpp: CTaskOneDoc 类的实现
//

#include "pch.h"
#include "framework.h"
// SHARED_HANDLERS 可以在实现预览、缩略图和搜索筛选器句柄的
// ATL 项目中进行定义，并允许与该项目共享文档代码。
#ifndef SHARED_HANDLERS
#include "TaskOne.h"
#endif

#include "TaskOneDoc.h"

#include <propkey.h>
#include"MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// CTaskOneDoc

IMPLEMENT_DYNCREATE(CTaskOneDoc, CDocument)

BEGIN_MESSAGE_MAP(CTaskOneDoc, CDocument)
END_MESSAGE_MAP()


// CTaskOneDoc 构造/析构

CTaskOneDoc::CTaskOneDoc() noexcept
{
	// TODO: 在此添加一次性构造代码

}

CTaskOneDoc::~CTaskOneDoc()
{
}

BOOL CTaskOneDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	// TODO: 在此添加重新初始化代码
	// (SDI 文档将重用该文档)

	return TRUE;
}

void CTaskOneDoc::AddShap(CSharp* pShap)
{
	m_vecShap.push_back(pShap);
}




// CTaskOneDoc 序列化

void CTaskOneDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: 在此添加存储代码
		CString strTitle = _T("my test");
		ar << strTitle;
		ar << m_vecShap.size();
		for (int i = 0; i < (int)m_vecShap.size(); i++)
		{
			ShapType Type = m_vecShap[i]->type();
			ar << (int)Type;
			switch (Type)
			{
				case knone:
					break;
				case kLine:
					ar << *(Cline*)m_vecShap[i];
					break;
				case kCircle:
					ar << *(CCircle*)m_vecShap[i];
					break;
				case kEllip:
					ar << *(CEllipse*)m_vecShap[i];
					break;
				case kRect:
					ar << *(Rectangle1*)m_vecShap[i];
					break;
				default:
					break;
			}
		}
	}
	else
	{
		CString str;
		ar >> str;
		if (str != _T("my test"))
		{
			AfxMessageBox(_T("非保存文件！"));
		}
		else
		{
			int size;
			ar >> size;
			for(int i = 0; i < size; i++)
			{
				int tmpType ;
				ar >> tmpType;
				ShapType Type =(ShapType)tmpType;
				CSharp* pShap = NULL;
				switch (Type)
				{
				case knone:
					break;
				case kLine:
				{
					pShap = new Cline();
					ar >> *(Cline*)pShap;
					break;
				}	
				case kCircle:
				{
					pShap = new CCircle();
					ar >> *(CCircle*)pShap;
					break;
				}		
				case kEllip:
				{
					pShap = new CEllipse();
					ar >> *(CEllipse*)pShap;
					break;
				}
				case kRect:
				{
					pShap = new Rectangle1();
					ar >> *(Rectangle1*)pShap;
					break;
				}
				default:
					break;
				}
				m_vecShap.push_back(pShap);
			}
		}


		// TODO: 在此添加加载代码
	}
}

#ifdef SHARED_HANDLERS

// 缩略图的支持
void CTaskOneDoc::OnDrawThumbnail(CDC& dc, LPRECT lprcBounds)
{
	// 修改此代码以绘制文档数据
	dc.FillSolidRect(lprcBounds, RGB(255, 255, 255));

	CString strText = _T("TODO: implement thumbnail drawing here");
	LOGFONT lf;

	CFont* pDefaultGUIFont = CFont::FromHandle((HFONT) GetStockObject(DEFAULT_GUI_FONT));
	pDefaultGUIFont->GetLogFont(&lf);
	lf.lfHeight = 36;

	CFont fontDraw;
	fontDraw.CreateFontIndirect(&lf);

	CFont* pOldFont = dc.SelectObject(&fontDraw);
	dc.DrawText(strText, lprcBounds, DT_CENTER | DT_WORDBREAK);
	dc.SelectObject(pOldFont);
}

// 搜索处理程序的支持
void CTaskOneDoc::InitializeSearchContent()
{
	CString strSearchContent;
	// 从文档数据设置搜索内容。
	// 内容部分应由“;”分隔

	// 例如:     strSearchContent = _T("point;rectangle;circle;ole object;")；
	SetSearchContent(strSearchContent);
}

void CTaskOneDoc::SetSearchContent(const CString& value)
{
	if (value.IsEmpty())
	{
		RemoveChunk(PKEY_Search_Contents.fmtid, PKEY_Search_Contents.pid);
	}
	else
	{
		CMFCFilterChunkValueImpl *pChunk = nullptr;
		ATLTRY(pChunk = new CMFCFilterChunkValueImpl);
		if (pChunk != nullptr)
		{
			pChunk->SetTextValue(PKEY_Search_Contents, value, CHUNK_TEXT);
			SetChunkValue(pChunk);
		}
	}
}

#endif // SHARED_HANDLERS

// CTaskOneDoc 诊断

#ifdef _DEBUG
void CTaskOneDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CTaskOneDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG


// CTaskOneDoc 命令