• 五、MFC视图窗口和文档

    一、视图窗口

            提供一个用于显示数据的窗口

    1、视图窗口相关类

            CView及其子类，父类为CWnd类，封装了关于视图窗口的各种操作，以及和文档类的数据交互

    2、视图窗口的使用

    （1）定义了一个自己的视图类（CMyView），派生自CView，并重写父类成员纯虚函数void OnDraw(CDC* pDC)，可以用于绘图

    （2）其余框架类和应用类程序代码不变

    （3）处理框架的WM_CREATE消息时，定义CMyView类对象，并调用Create函数创建视图窗口，视图窗口的ID为 AFX_IDW_PANE_FIRST

    3、创建项目（MFCView）

    （1）创建项目

    （2）编写程序

    1. #include 
    2. #include "resource.h"
    3.  
    4. class CMyView:public CView
    5. {
    6. 	DECLARE_MESSAGE_MAP()
    7. public:
    8. 	virtual void OnDraw(CDC* pDC);
    9. 	afx_msg void OnPaint();
    10. 	afx_msg void OnNew();
    11. };
    12. BEGIN_MESSAGE_MAP(CMyView, CView)
    13. 	//ON_WM_PAINT()
    14. 	ON_COMMAND(ID_NEW, OnNew)
    15. END_MESSAGE_MAP()
    16.  
    17. //父类处理绘图消息时会调用OnDraw，当本类由绘图消息处理，则OnDraw不会被调用
    18. void CMyView::OnDraw(CDC* pDC)
    19. {
    20. 	pDC->TextOut(100, 100, "CMyView::OnDraw");
    21. }
    22. void CMyView::OnPaint()
    23. {
    24. 	PAINTSTRUCT ps = {0};
    25. 	HDC hdc = ::BeginPaint(m_hWnd, &ps);
    26. 	::TextOutA(hdc, 200, 200, "CMyView::OnPaint", strlen("CMyView::OnPaint"));
    27. 	::EndPaint(m_hWnd, &ps);
    28. }
    29. void CMyView::OnNew()
    30. {
    31. 	AfxMessageBox("视图类处理了OnNew消息");
    32. }
    33.  
    34. class CMyFrameWnd:public CFrameWnd
    35. {
    36. 	DECLARE_MESSAGE_MAP()
    37. public:
    38. 	afx_msg void OnPaint();
    39. 	afx_msg int OnCreate(LPCREATESTRUCT pcs);
    40. 	afx_msg void OnNew();
    41. };
    42. BEGIN_MESSAGE_MAP(CMyFrameWnd, CFrameWnd)
    43. 	ON_WM_CREATE()
    44. 	ON_WM_PAINT()
    45. 	ON_COMMAND(ID_NEW, OnNew)
    46. END_MESSAGE_MAP()
    47.  
    48. int CMyFrameWnd::OnCreate(LPCREATESTRUCT pcs)
    49. {
    50. 	CMyView* pView = new CMyView;
    51. 	pView->Create(NULL, "MFCView", WS_CHILD|WS_VISIBLE|WS_BORDER, CRect(0, 0, 200, 200), 
    52. 				this, AFX_IDW_PANE_FIRST);		//AFX_IDW_PANE_FIRST 生成的视图窗口会平铺在框架窗口
    53. 	m_pViewActive = pView;	//将窗口赋值给活动窗口
    54. 	return CFrameWnd::OnCreate(pcs);
    55. }
    56.  
    57. void CMyFrameWnd::OnPaint()
    58. {
    59. 	PAINTSTRUCT ps = {0};
    60. 	HDC hdc = ::BeginPaint(m_hWnd, &ps);
    61. 	::TextOutA(hdc, 100, 100, "框架窗口客户区", strlen("框架窗口客户区"));
    62. 	::EndPaint(m_hWnd, &ps);
    63. }
    64. void CMyFrameWnd::OnNew()
    65. {
    66. 	AfxMessageBox("框架类处理了OnNew消息");
    67. }
    68.  
    69.  
    70. class CMyWinApp:public CWinApp
    71. {
    72. 	DECLARE_MESSAGE_MAP()
    73. public:
    74. 	virtual BOOL InitInstance();
    75. 	afx_msg void OnNew();
    76. };
    77. BEGIN_MESSAGE_MAP(CMyWinApp, CWinApp)
    78. 	ON_COMMAND(ID_NEW, OnNew)
    79. END_MESSAGE_MAP()
    80. void CMyWinApp::OnNew()
    81. {
    82. 	AfxMessageBox("框架类处理了OnNew消息");
    83. }
    84.  
    85. BOOL CMyWinApp::InitInstance()
    86. {
    87. 	CMyFrameWnd* pFrame = new CMyFrameWnd;
    88. 	pFrame->Create(NULL, "MFCView", WS_OVERLAPPEDWINDOW, CFrameWnd::rectDefault,NULL,
    89. 				(char*)IDR_MENU1);
    90. 	m_pMainWnd = pFrame;
    91. 	pFrame->ShowWindow(SW_SHOW);
    92. 	pFrame->UpdateWindow();
    93. 	return TRUE;
    94. }
    95.  
    96. CMyWinApp theApp;

    （3）命令消息处理顺序

            视图类 -》 框架类 -》 应用程序类

    （4）对象关系图

    1. theApp
    2.     theApp->m_pMainWnd = pFrame
    3.         pFrame->m_pViewActive = pView
    4.

    二、文档类

            相关类 CDocument，提供了用于管理数据的类，封装了关于数据的管理（数据提取，数据转换，数据存储等），并和视图类进行数据交互。

    1、创建项目

    （1）创建项目（MFCDoc）

    （2）编写程序

    1. #include 
    2. #include 
    3. #include "resource.h"
    4.  
    5. class CMyDoc:public CDocument
    6. {
    7.  
    8. };
    9.  
    10. class CMyView:public CView
    11. {
    12. 	DECLARE_DYNCREATE(CMyView)
    13. 	DECLARE_MESSAGE_MAP()
    14. public:
    15. 	virtual void OnDraw(CDC* cDC);
    16. 	afx_msg int OnCreate(LPCREATESTRUCT pcs);
    17. };
    18. IMPLEMENT_DYNCREATE(CMyView, CView)
    19. BEGIN_MESSAGE_MAP(CMyView, CView)
    20. 	ON_WM_CREATE()
    21. END_MESSAGE_MAP()
    22.  
    23. void CMyView::OnDraw(CDC* cDC)
    24. {
    25. 	cDC->TextOut(100, 100, "视图窗口");
    26. }
    27. int CMyView::OnCreate(LPCREATESTRUCT pcs)
    28. {
    29. 	return CView::OnCreate(pcs);
    30. }
    31.  
    32. class CMyFrameWnd:public CFrameWnd
    33. {
    34. 	DECLARE_MESSAGE_MAP()
    35. 	afx_msg int OnCreate(LPCREATESTRUCT pcs);
    36. 	afx_msg void OnPaint();
    37. };
    38. BEGIN_MESSAGE_MAP(CMyFrameWnd, CFrameWnd)
    39. 	ON_WM_CREATE()
    40. 	ON_WM_PAINT()
    41. END_MESSAGE_MAP()
    42. int CMyFrameWnd::OnCreate(LPCREATESTRUCT pcs)
    43. {
    44. 	return CFrameWnd::OnCreate(pcs);
    45. }
    46. void CMyFrameWnd::OnPaint()
    47. {
    48. 	PAINTSTRUCT ps = {0};
    49. 	HDC hdc = ::BeginPaint(m_hWnd, &ps);
    50. 	::TextOutA(hdc, 200, 200, "CMyFrameWnd::OnPaint", strlen("CMyFrameWnd::OnPaint"));
    51. 	::EndPaint(m_hWnd, &ps);
    52. }
    53.  
    54. class CMyWinApp:public CWinApp
    55. {
    56. public:
    57. 	virtual BOOL InitInstance();
    58. };
    59. BOOL CMyWinApp::InitInstance()
    60. {
    61. 	CMyFrameWnd* pFrame = new CMyFrameWnd;
    62. 	CCreateContext cct;
    63. 	CMyDoc* pDoc = new CMyDoc;
    64. 	cct.m_pNewViewClass = RUNTIME_CLASS(CMyView);
    65. 	cct.m_pCurrentDoc = pDoc;
    66. 	pFrame->LoadFrame(IDR_MENU1, WS_OVERLAPPEDWINDOW, NULL, &cct);
    67. 	m_pMainWnd = pFrame;
    68. 	pFrame->ShowWindow(SW_SHOW);
    69. 	pFrame->UpdateWindow();
    70. 	return TRUE;
    71. }
    72. CMyWinApp theApp;

    （3）创建过程

            利用框架类对象地址（pFrame）调用LoadFrame函数，创建框架窗口

            在处理框架窗口的WM_CREATE消息时，（父类CFrameWnd）动态创建视图类对象，并创建视图窗口

            在处理视图窗口的WM_CREATE消息时，（父类CView）将文档类和视图类对象见理关系

    2、创建流程

    1. CMyFrameWnd* pFrame = new CMyFrameWnd;
    2. CMyDoc* pDoc = new CMyDoc;
    3.  
    4. CCreateContext cct;
    5. cct.m_pCurrentDoc = pDoc;//文档类对象地址
    6. cct.m_pNewViewClass = RUNTIME_CLASS(CMyView);//&CMyView::classCMyView
    7.  
    8. pFrame->LoadFrame(... &cct)//函数内部this为pFrame
    9. {
    10.   Create(...,&cct)//函数内部this为pFrame
    11.   {
    12.     CreateEx(...&cct)//函数内部this为pFrame
    13.     {
    14.       CREATESTRUCT cs;
    15.       ....
    16.       cs.lpCreateParams = &cct;
    17.       ::CreateWindowEx(...,&cct);//创建主框架窗口
    18.     }
    19.   }
    20. }
    21. //处理框架窗口的WM_CREATE消息
    22. CFrameWnd::OnCreate( pcs )//函数内部this为pFrame,参数可以获取::CreateWindowEx的12个参数
    23. {
    24.   CCreateContext* pContext = (CCreateContext*)pcs->lpCreateParams;//获取&cct
    25.   OnCreateHelper(pcs, pContext)//函数内部this为pFrame，pContext===&cct
    26.   {
    27.     OnCreateClient(pcs, pContext)//函数内部this为pFrame，pContext===&cct
    28.     {
    29.       CreateView(pContext..)//函数内部this为pFrame，pContext===&cct
    30.       {
    31.         CWnd* pView = pContext->m_pNewViewClass->CreateObject();
    32.                             //动态创建视图类对象，并返回对象地址
    33.         pView->Create(..,pContext)//函数内部this为pView，pContext===&cct
    34.         {
    35.           CreateEx(..,pContext）//函数内部this为pView，pContext===&cct
    36.           {
    37.             CREATESTRUCT cs;
    38.             ....
    39.             cs.lpCreateParams = pContext;//pContext===&cct
    40.             ::CreateWindowEx(...,pContext);//创建视图窗口         
    41.           }
    42.         }
    43.       }
    44.     }
    45.   }
    46. }
    47.  
    48. //处理视图窗口的WM_CREATE消息
    49. CView::OnCreate( pcs )//函数内部this为pView,参数可以获取::CreateWindowEx函数的12个参数
    50. {
    51.   CCreateContext* pContext = (CCreateContext*)lpcs->lpCreateParams;//获取&cct
    52.   pContext->m_pCurrentDoc->AddView(pView)//函数内部this为pDoc,参数为视图类对象地址
    53.   {
    54.     m_viewList.AddTail(pView);//文档类对象用一个链表成员变量,保存视图类对象地址
    55.     pView->m_pDocument = this;//视图类对象用一个普通成员变量,保存文档类对象地址
    56.   }
    57. }

    3、对象关系

    （1）文档类对象用一个链表成员变量，保存视图类对象地址

    （2）视图类对象用一个普通成员变量，保存文档类对象地址

            一个文档类对象可以对应多个视图类对象（视图窗口）

            一个视图类对象（视图窗口）只能对应一个文档类对象

    4、视图切分

    （1）相关类

    CSplitterWnd 不规则框架窗口类，分装了关于不规则框架窗口的操作

    （2）窗口切分的使用

    重写CFrameWnd类的成员虚函数OnCreateClient

            在虚函数中调用CSplitterWnd::CreateStatic创建不规则框架窗口

            在虚函数中调用CSplitterWnd::CreateView创建视图窗口

    （3）编写程序

    1. #include 
    2. #include 
    3. #include "resource.h"
    4.  
    5. class CMyDoc:public CDocument
    6. {
    7.  
    8. };
    9.  
    10. class CMyView:public CView
    11. {
    12. 	DECLARE_DYNCREATE(CMyView)
    13. 	DECLARE_MESSAGE_MAP()
    14. public:
    15. 	virtual void OnDraw(CDC* cDC);
    16. 	afx_msg int OnCreate(LPCREATESTRUCT pcs);
    17. };
    18. IMPLEMENT_DYNCREATE(CMyView, CView)
    19. BEGIN_MESSAGE_MAP(CMyView, CView)
    20. 	ON_WM_CREATE()
    21. END_MESSAGE_MAP()
    22.  
    23. void CMyView::OnDraw(CDC* cDC)
    24. {
    25. 	cDC->TextOut(100, 100, "视图窗口");
    26. }
    27. int CMyView::OnCreate(LPCREATESTRUCT pcs)
    28. {
    29. 	return CView::OnCreate(pcs);
    30. }
    31.  
    32. class CMyFrameWnd:public CFrameWnd
    33. {
    34. 	DECLARE_MESSAGE_MAP()
    35. 	afx_msg int OnCreate(LPCREATESTRUCT pcs);
    36. 	afx_msg void OnPaint();
    37. 	virtual BOOL OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext);
    38. private:
    39. 	CSplitterWnd m_split;	//不规则框架窗口
    40. };
    41. BEGIN_MESSAGE_MAP(CMyFrameWnd, CFrameWnd)
    42. 	ON_WM_CREATE()
    43. 	ON_WM_PAINT()
    44. END_MESSAGE_MAP()
    45. int CMyFrameWnd::OnCreate(LPCREATESTRUCT pcs)
    46. {
    47. 	return CFrameWnd::OnCreate(pcs);
    48. }
    49. void CMyFrameWnd::OnPaint()
    50. {
    51. 	PAINTSTRUCT ps = {0};
    52. 	HDC hdc = ::BeginPaint(m_hWnd, &ps);
    53. 	::TextOutA(hdc, 200, 200, "CMyFrameWnd::OnPaint", strlen("CMyFrameWnd::OnPaint"));
    54. 	::EndPaint(m_hWnd, &ps);
    55. }
    56. BOOL CMyFrameWnd::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)
    57. {
    58. 	//创建两个视图窗口	
    59. 	m_split.CreateStatic(this, 1, 2);
    60. 	m_split.CreateView(0, 0, RUNTIME_CLASS(CMyView), CSize(100, 100), pContext);
    61. 	m_split.CreateView(0, 1, pContext->m_pNewViewClass, CSize(100, 100), pContext);
    62.     m_pViewActive = (CView*)m_split.GetPane(0,0);	//设置活动窗口
    63. 	return TRUE;
    64. }
    65. class CMyWinApp:public CWinApp
    66. {
    67. public:
    68. 	virtual BOOL InitInstance();
    69. };
    70. BOOL CMyWinApp::InitInstance()
    71. {
    72. 	CMyFrameWnd* pFrame = new CMyFrameWnd;
    73. 	CCreateContext cct;
    74. 	CMyDoc* pDoc = new CMyDoc;
    75. 	cct.m_pNewViewClass = RUNTIME_CLASS(CMyView);
    76. 	cct.m_pCurrentDoc = pDoc;
    77. 	pFrame->LoadFrame(IDR_MENU1, WS_OVERLAPPEDWINDOW, NULL, &cct);
    78. 	m_pMainWnd = pFrame;
    79. 	pFrame->ShowWindow(SW_SHOW);
    80. 	pFrame->UpdateWindow();
    81. 	return TRUE;
    82. }
    83. CMyWinApp theApp;

    三、命令消息（WM_COMMAND）处理顺序

            对象关系图

    1、编写程序

    1. #include 
    2. #include 
    3. #include "resource.h"
    4.  
    5. class CMyDoc:public CDocument
    6. {
    7. 	DECLARE_MESSAGE_MAP()
    8. public:
    9. 	afx_msg void OnNew();
    10. };
    11. BEGIN_MESSAGE_MAP(CMyDoc, CDocument)
    12. 	//ON_COMMAND(ID_NEW, OnNew)
    13. END_MESSAGE_MAP()
    14.  
    15. void CMyDoc::OnNew()
    16. {
    17. 	AfxMessageBox("CMyDoc::OnNew");
    18. }
    19.  
    20. class CMyView:public CView
    21. {
    22. 	DECLARE_DYNCREATE(CMyView)
    23. 	DECLARE_MESSAGE_MAP()
    24. public:
    25. 	virtual void OnDraw(CDC* cDC);
    26. 	afx_msg int OnCreate(LPCREATESTRUCT pcs);
    27. 	afx_msg void OnNew();
    28. };
    29. IMPLEMENT_DYNCREATE(CMyView, CView)
    30. BEGIN_MESSAGE_MAP(CMyView, CView)
    31. 	ON_WM_CREATE()
    32. 	//ON_COMMAND(ID_NEW, OnNew)
    33. END_MESSAGE_MAP()
    34.  
    35. void CMyView::OnDraw(CDC* cDC)
    36. {
    37. 	cDC->TextOut(100, 100, "视图窗口");
    38. }
    39. int CMyView::OnCreate(LPCREATESTRUCT pcs)
    40. {
    41. 	return CView::OnCreate(pcs);
    42. }
    43. void CMyView::OnNew()
    44. {
    45. 	AfxMessageBox("CMyView::OnNew");
    46. }
    47.  
    48. class CMyFrameWnd:public CFrameWnd
    49. {
    50. 	DECLARE_MESSAGE_MAP()
    51. 	afx_msg int OnCreate(LPCREATESTRUCT pcs);
    52. 	afx_msg void OnPaint();
    53. 	virtual BOOL OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext);
    54. 	afx_msg void OnNew();
    55. private:
    56. 	CSplitterWnd m_split;	//不规则框架窗口
    57. };
    58. BEGIN_MESSAGE_MAP(CMyFrameWnd, CFrameWnd)
    59. 	ON_WM_CREATE()
    60. 	ON_WM_PAINT()
    61. 	ON_COMMAND(ID_NEW, OnNew)
    62. END_MESSAGE_MAP()
    63. int CMyFrameWnd::OnCreate(LPCREATESTRUCT pcs)
    64. {
    65. 	return CFrameWnd::OnCreate(pcs);
    66. }
    67. void CMyFrameWnd::OnPaint()
    68. {
    69. 	PAINTSTRUCT ps = {0};
    70. 	HDC hdc = ::BeginPaint(m_hWnd, &ps);
    71. 	::TextOutA(hdc, 200, 200, "CMyFrameWnd::OnPaint", strlen("CMyFrameWnd::OnPaint"));
    72. 	::EndPaint(m_hWnd, &ps);
    73. }
    74. BOOL CMyFrameWnd::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)
    75. {
    76. 	//创建两个视图窗口	
    77. 	m_split.CreateStatic(this, 1, 2);
    78. 	m_split.CreateView(0, 0, RUNTIME_CLASS(CMyView), CSize(100, 100), pContext);
    79. 	m_split.CreateView(0, 1, pContext->m_pNewViewClass, CSize(100, 100), pContext);
    80. 	m_pViewActive = (CView*)m_split.GetPane(0,0);	//设置活动窗口
    81. 	return TRUE;
    82. }
    83. void CMyFrameWnd::OnNew()
    84. {
    85. 	AfxMessageBox("CMyFrameWnd::OnNew");
    86. }
    87. class CMyWinApp:public CWinApp
    88. {
    89. 	DECLARE_MESSAGE_MAP()
    90. public:
    91. 	virtual BOOL InitInstance();
    92. 	afx_msg void OnNew();
    93. };
    94. BEGIN_MESSAGE_MAP(CMyWinApp, CWinApp)
    95. 	ON_COMMAND(ID_NEW, OnNew)
    96. END_MESSAGE_MAP()
    97.  
    98. void CMyWinApp::OnNew()
    99. {
    100. 	AfxMessageBox("CMyWinApp::OnNew");
    101. }
    102.  
    103. BOOL CMyWinApp::InitInstance()
    104. {
    105. 	CMyFrameWnd* pFrame = new CMyFrameWnd;
    106. 	CCreateContext cct;
    107. 	CMyDoc* pDoc = new CMyDoc;
    108. 	cct.m_pNewViewClass = RUNTIME_CLASS(CMyView);
    109. 	cct.m_pCurrentDoc = pDoc;
    110. 	pFrame->LoadFrame(IDR_MENU1, WS_OVERLAPPEDWINDOW, NULL, &cct);
    111. 	m_pMainWnd = pFrame;
    112. 	pFrame->ShowWindow(SW_SHOW);
    113. 	pFrame->UpdateWindow();
    114. 	return TRUE;
    115. }
    116. CMyWinApp theApp;

    2、处理顺序

    视图类 -》文档类 -》框架列 -》 应用类

    3、消息执行流程

    1. //WM_COMMAND消息的路线
    2. OnCommand(wParam, lParam)//函数内部this为pFrame
    3. {
    4.   CWnd::OnCommand(..)//函数内部this为pFrame
    5.   {
    6.     OnCmdMsg(...)//函数内部this为pFrame   *****CFrameWnd::OnCmdMsg 起点
    7.     {
    8.       CView* pView = GetActiveView()//函数内部this为pFrame
    9.       {
    10.         return this->m_pViewActive;//活动视图窗口对象地址
    11.       }对象
    12.       pView->OnCmdMsg(..) ===>终点 CCmdTarget::OnCmdMsg 此函数内部this为pView
    13.       m_pDocument->OnCmdMsg(.)==>终点CCmdTarget::OnCmdMsg 此函数内部this为文档类对象
    14.       CWnd::OnCmdMsg(..)==>终点 CCmdTarget::OnCmdMsg 此函数内部this为pFrame
    15.  
    16.       CWinApp* pApp = AfxGetApp();//获取&theApp
    17.       pApp->OnCmdMsg(..)==>终点 CCmdTarget::OnCmdMsg 此函数内部this为&theApp      
    18.     }
    19.   }
    20. }

  • 相关阅读:
    简易磁盘自动监控服务
    Shopee店铺ID是什么？Shopee店铺id怎么看？——站斧浏览器
    【C语言】整形数据的存储
    亚马逊日本站坠落防护安全装备JIST8165标准怎么办理？
    代码随想录训练营二刷第三十二天 | 122.买卖股票的最佳时机II 55. 跳跃游戏 45.跳跃游戏II
    如何写一个中间件的springboot的starter？
    Win11 22H2如何创建开始菜单文件夹？
    哪些偏门项目可以做到？自媒体做到月赚一万以上很难吗？
    RS485和RS232有什么区别？工业网关能用吗？
    【学习笔记】CF1817F Entangled Substrings（基本子串结构）
  • 原文地址：https://blog.csdn.net/liutit/article/details/125983373