文档类
1 文档类相关
对数据的管理
CDocument-父类是CCmdTarget类，提供文档数据的管理
2 文档类的使用
2.1 创建过程
2.1.1 调用CFrameWnd的LoadFrame函数，调用Create函数创建Frame窗口
2.1.2 在Frame的OnCreate函数中，先动态创建视图对象，在根据对象动态的创建View（视图）窗口
2.1.3 在View的OnCreate函数中，将View的地址保存到Document（文档）中，将Document的地址保存到View中
例：//文档类
class CMyDocument:public CDocument
{
DECLARE_DYNCREATE(CMyDocument)//动态创建声明宏
public:
CMyDocument();
CString m_strData;//保存文档中数据的成员
};
IMPLEMENT_DYNCREATE(CMyDocument,CDocument)//动态创建实现宏
//视图类
class CDocView:public CEditView
{
DECLARE_DYNCREATE(CDocView)//动态创建声明宏
public:
virtual void OnInitialUpdate();//CView中的OnInitialUpdate()虚函数
};
IMPLEMENT_DYNCREATE(CDocView,CEditView)//动态创建实现宏
// OnInitialUpdate()虚函数的重写(为了在视图中显示文档中数据)【1】
void CDocView::OnInitialUpdate()
{
//获取文档的指针
C MyDocument *pDc=(CMyDocument*)GetDocument();
//根据文档指针显示文档中定义好的数据
S etWindowText(pDc->m_strData);
}
//应用程序类
class CMainApp:public CWinApp
{
public:
virtual BOOL InitInstance();
};
//主窗体类
class CMainFrame:public CFrameWnd
{
public:
};
CMainApp theApp;
BOOL CMainApp::InitInstance()
{
CMainFrame *pFrame=new CMainFrame();
CCreateContext context;//定义一个结构体保存构成窗口的视图，文档等信息【2】
context.m_pCurrentDoc=new CMyDocument();//动态绑定文档类保存进结构
context.m_pNewViewClass=RUNTIME_CLASS(CDocView);//动态绑定视图类保存进结构
//调用CFrameWnd::Create函数创建主窗体，在创建消息处理函数中动态的创建了视图
//在视图的创建消息处理函数中，将视图和文档的地址相互保存进对方
pFrame->LoadFrame(IDR_MENU1,WS_OVERLAPPEDWINDOW,NULL,&context);
//让框架通知文档视图更新(视图根据文档中数据更新)
pFrame->InitialUpdateFrame(NULL,TRUE);
m_pMainWnd=pFrame;
m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateData();
return TRUE;
}
相关：【1】OnInitialUpdate
视图窗口完全建立后第一个被框架调用的函数。框架在第一次调用OnDraw前会调用
OnInitialUpdate，因此OnInitialUpdate是设置滚动视图的逻辑尺寸和映射模式的最合的地方。时间上，两者先后顺序不同，构造函数生成本类的对象，但没有产生窗口，OnCreate 后窗口产生，然后才是视图的OnInitialUpDate，一般在这里对视图的显示做初始化。简单点,就是ONCREATE只是产生VIEW的基本结构和变量而在OnInitialUpDate()中,主要初始化视图中控件等。对各个变量进行初始化操作。
【2】CCreateContext
在主程序创建框架窗口、以及文档相关的视图时，会使用CCreateContext结构。建立窗口时，此结构中的值用于连接构成文档的组件和文档数据的视图。仅当覆盖了创建过程时才需要使用CCreateContext。
CCreateContext结构包含了指向文档、框架窗口和文档模板的指针，包括了一个
CRuntimeClass指针，CRuntimeClass标志了待创建的视图的类型。运行时类信息和当前文档指针用于动态地创建视图。下表列出了CCreateContext的每个成员的用法：m_pNewViewClass：待创建的视图的CRuntimeClass
m_pCurrentDoc：将在其上创建视图的文档
m_pNewDocTemplate：待创建的新MDI框架窗口的文档模板
m_pLastView：待创建视图所依据的原始视图，例如在创建分裂窗口的视图或文档的第二个框架窗口时
m_pCurrentFrame：待创建框架窗口所依据的框架窗口，例如在文档上创建第二个框架窗口时
2.2 创建的这些类是如何相关联的（都有一个变量保存相关联的那个的地址）
CWinApp
|->m_pMainWnd(CFrameWnd)
|->m_pViewActive(CView)
|->m_pDocument(CDocument)
|->m_viewList(Ciew的LIst)
一个文档数据可以用多个视图来创建，一个视图只能显示一个文档那个数据
2.3 命令消息的响应顺序
View->Document->Frame->App
自己定义的类也可以响应命令消息，只需要继承字CCmdTarget而且响应的优先级也可以自定，只需要将系统那几个主要的类中的虚消息响应函数重写即可
★例：自己定义的类的命令消息响应优先级高于文档类
//自己定义的类
class CMyData:public CCmdTarget
{
DECLARE_MESSAGE_MAP()//消息响应声明宏
public:
afx_msg void OnTest();//消息处理函数
};
BEGIN_MESSAGE_MAP(CMyData,CCmdTarget)//消息响应实现宏
ON_COMMAND(ID_TEST,OnTest)
END_MESSAGE_MAP()
//自定义类中对消息处理的函数
void CMyData::OnTest()
{
AfxMessageBox("CMyData::OnTest");【3】
}
//文档类
class CMyDocument:public CDocument
{
DECLARE_MESSAGE_MAP()
public:
CMyDocument();
afx_msg void OnTest();
//文档类的消息响应函数声明
virtual BOOL OnCmdMsg( UINT nID,int nCode, void* pExtra,
AFX_CMDHANDLERINFO* pHandlerInfo );
public:
CMyData m_data;//自定义类的对象
CString m_strData;
};
//文档类的构造函数实现
CMyDocument::CMyDocument()
{
m_strData="Hello Doc";
}
BEGIN_MESSAGE_MAP(CMyDocument,CDocument)
ON_COMMAND(ID_TEST,OnTest)
END_MESSAGE_MAP()
//文档类的消息响应函数重写（定义自定义类消息响应优先级高于文档类）BOOL CMyDocument::OnCmdMsg(UINT nID, int nCode,void* pExtra,
AFX_CMDHANDLERINFO* pHandlerInfo)
{
if (m_data.OnCmdMsg(nID,nCode,pExtra,pHandlerInfo))
{
return TRUE;
}
return CDocument::OnCmdMsg(nID,nCode,pExtra,pHandlerInfo);
}
//文档类对消息处理的函数
void CMyDocument::OnTest()
{
AfxMessageBox("CMyDocument::OnTest");【3】
}
//视图类
class CDocView:public CEditView
{
DECLARE_DYNCREA TE(CDocView)
DECLARE_MESSAGE_MAP()
public:
virtual void OnInitialUpdate( );
afx_msg void OnTest();
};
IMPLEMENT_DYNCREATE(CDocView,CEditView)
BEGIN_MESSAGE_MAP(CDocView,CEditView)
//ON_COMMAND(ID_TEST,OnTest)
END_MESSAGE_MAP()
//视图类消息处理函数
void CDocView::OnTest()
{
MessageBox("CDocView");【3】
}
窗口类本身调用MessageBox就行
文档类等就得调用AfxMessageBox
…
…
★2.4 View显示来自Document的数据【1】
OnInitialUpdate()->在View被创建后，首次关联文档后，显示前调用
单文档视图程序
1 单文档视图程序
只能管理一个文档
2 相关类
2.1 CWinApp/CFrameWnd/Cview/CDocument
2.2 文档模板类CDocTemplate（抽象基类）父类是CCmdTarget
两个子类：CSingleDocTemplate-单文档模板
CMultiDocTemplate-多文档模板
3 单文档CSingleDocTemplate
CSingleDocTemplate类定义了一个文档模板用于实现单文档界面（SDI）。一个SDI应用程序使用主框架窗口来显示一个文档；一次只能打开一个文档。
★一个文档模板定义了类的三个类型之间的关系：
★1 一个从CDocument派生而来的文档类。
★2 一个视图类，用来显示来自上面提到的文档类的数据。你可以从CView，CScrollView，CFormView，或CEditView派生这个类。（你也可以直接使用CEditView。）
★3 一个框架窗口类，用来包容视图。对于一个SDI文档模板，你可以从CFrameWnd派生这个类；
如果你不需要定制主框架窗口的行为，你可以直接使用CFrameWnd，而不派生你自己的类。
★一个SDI应用程序通常支持一种类型的文档，因此它只有一个CSingleDocTemplate模板。一次只打开一个文档。
除了CSingleDocTemplate的构造函数，你不需要调用它的任何其它成员函数。框架在内部处理CSingleDocTemplate对象。
构造函数：
CSingleDocTemplate( UINT nIDResource,//加载资源ID
CRuntimeClass* pDocClass, //文档类
CRuntimeClass* pFrameClass, //框架窗口类
CRuntimeClass* pViewClass ); //视图类
例：//文档类
class CSdiDoc:public CDocument
{
DECLARE_DYNCREATE(CSdiDoc)//动态创建声明宏
public:
};
IMPLEMENT_DYNCREATE(CSdiDoc,CDocument)//动态创建实现宏
//视图类
class CSdiView:public CEditView
{
DECLARE_DYNCREATE(CSdiView)//动态创建声明宏
public:
};
IMPLEMENT_DYNCREATE(CSdiView,CEditView)//动态创建实现宏
//应用程序类
class CMainApp:public CWinApp
{
public:
virtual BOOL InitInstance();
};
//主窗体类
class CMainFrame:public CFrameWnd
{
DECLARE_MESSAGE_MAP()//消息映射(Map)声明(Declare)宏
DECLARE_DYNCREATE(CMainFrame)//动态创建声明宏
public:
};
IMPLEMENT_DYNCREATE(CMainFrame,CFrameWnd)//动态创建实现宏
BEGIN_MESSAGE_MAP(CMainFrame,CFrameWnd)//主窗体消息映射实现宏
END_MESSAGE_MAP()
CMainApp theApp;
BOOL CMainApp::InitInstance()
{ //动态创建不用指明对象，用类即可
CSingleDocTemplate *pTemplate=new CsingleDocTemplate(IDR_MENU1,
RUNTIME_CLASS(CsdiDoc),
RUNTIME_CLASS(CmainFrame),
RUNTIME_CLASS(CsdiView));
AddDocTemplate(pTemplate);//加载单文档模板
//新建文档
OnFileNew(); //创建的关键函数
m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateData();
return TRUE;
}
4 创建过程
4.1 关系
CWinApp
//文档模板管理对象（AddDocTemplate函数中的，将创建好的模板给他）
|->m_pDocManager(CDocManager*)
|->m_templateList(CDocTemplate List)(保存文档模板的链表，证明模板可以有多个)
|->CSingleDocTemplate
|->CRuntimeClass *m_pDocClass//文档
|->CRuntimeClass *m_pFrameClass //主框架窗口
|->CRuntimeClass *m_pViewClass //视图
★|->CRuntimeClass *m_pOnlyDoc//单文档程序中那个文档对象指针
（单文档程序只能有一个文档）
4.2 创建过程（在OnFileNew函数中执行）
4.2.1 使用m_pDocManager从m_templateList中获取文档模板的第一个，因为是单文档视图窗口
类，所以如果有多个模板的话，用字符串表区分模板，程序会弹出对话框选择用哪个模板创建程序，字符串表的信息中，用‘\n’隔开三段，分别对应（窗口的标题，视图窗口标题，文档的标题）
4.2.2 使用文档模板中的m_pDocClass创建文档对象
4.2.3 使用文档模板中的m_pFrameClass创建Frame对象
4.2.4 将文档对象和m_pViewClass传给Frame对象，并调用LoadFrame创建Frame窗口
4.2.5 在Frame的OnCreate函数中，创建视图对象和窗口
4.2.6 在View的OnCreate函数中，间View的地址保存到Document中，将Document的地址保
存到View中。
多文档视图应用程序
1 多文档视图
同时能够打开多个文档进行处理
2 多文档视图相关
2.1 相关类
CWinApp / CMDIFrameWnd / CMDIChildWnd / Cview / CDocument
2.2 文档模板
CMultiDocTemplate-多文档模板
3 使用
4 创建过程
4.1关系
CWinApp
//文档模板管理器对象的指针（AddDocTemplate函数中的，将创建好的模板给他）
|->m_pDocManager(CDocManager*)
|->m_templateList(CDocTemplate List)(保存文档模板的链表，证明模板可以有多个)
|->CMultiDocTemplate
|->CRuntimeClass *m_pDocClass//子框架窗口的文档
|->CRuntimeClass *m_pFrameClass //子框架窗口
|->CRuntimeClass *m_pViewClass //子框架窗口的视图
★|->m_docList(CDocument List)//多文档子窗体存储链表
4.2创建（OnFileNew）与单文档类似
★MDI多文档视图窗口例子：
#include "stdafx.h"
#include "resource.h"
//文档类
class CMdiDoc:public CDocument
{ DECLARE_DYNCREATE(CMdiDoc)//动态创建声明宏
public:
CString m_strText;
};
IMPLEMENT_DYNCREATE(CMdiDoc,CDocument)//动态创建实现宏
//视图类
class CMdiView:public CEditView
{
DECLARE_DYNCREATE(CMdiView)//动态创建声明宏
DECLARE_MESSAGE_MAP()//消息映射(Map)声明(Declare)宏
public:
//CView的OnUpdate虚函数
virtual void OnUpdate( CView* pSender, LPARAM lHint, CObject* pHint );
afx_msg void OnEnChange();
};
IMPLEMENT_DYNCREATE(CMdiView,CEditView)//动态创建实现宏
BEGIN_MESSAGE_MAP(CMdiView,CEditView)//主窗体消息映射实现宏
ON_CONTROL_REFLECT_EX(EN_CHANGE,OnEnChange)//文档视图中数据发生变化时产生的消息END_MESSAGE_MAP()
//应用程序类
class CMdiApp:public CWinApp
{
DECLARE_MESSAGE_MAP()//消息映射(Map)声明(Declare)宏
public:
virtual BOOL InitInstance();
afx_msg void OnNew();
};
BEGIN_MESSAGE_MAP(CMdiApp,CWinApp)//主窗体消息映射实现宏
ON_COMMAND(ID_NEW,OnNew)//新建子窗口消息映射
END_MESSAGE_MAP()
★//新建子窗口函数
void CMdiApp::OnNew()
{
OnFileNew();//直接调用应用程序类的OnFileNew即可
}
//主窗体类
class CMainFrame:public CMDIFrameWnd
{
DECLARE_MESSAGE_MAP()//消息映射(Map)声明(Declare)宏
public:
afx_msg void OnNewView();
};
BEGIN_MESSAGE_MAP(CMainFrame,CFrameWnd)//主窗体消息映射实现宏
ON_COMMAND(ID_NEWVIEW,OnNewView)//创建新视图消息映射
END_MESSAGE_MAP()
//子窗体类
class CChildFrame:public CMDIChildWnd
{ DECLARE_DYNCREATE(CChildFrame)//动态创建声明宏
public:
};
IMPLEMENT_DYNCREATE(CChildFrame,CMDIChildWnd)//动态创建实现宏
★//创建新视图消息处理函数
void CMainFrame::OnNewView()
{
//获取当前编辑文档
CFrameWnd *pFrameWnd=GetActiveFrame();//获取当前活动窗口
if(pFrameWnd->IsKindOf(RUNTIME_CLASS(CChildFrame)))
return;
CView *pView=pFrameWnd->GetActiveView();//根据当前活动窗口获取他得视图
CDocument *pDoc=pView->GetDocument();//根据视图获取当前活动窗口的文档对象
//基于这个文档创建新的Frame包含视图窗口
CDocTemplate *pTemplate=pDoc->GetDocTemplate();//获得这个文档的模板
CChildFrame *pNewFrame=(CChildFrame *)pTemplate->CreateNewFrame(pDoc,NULL);//根据模板，和文档指针，创建新的子窗口
pTemplate->InitialUpdateFrame(pNewFrame,pDoc);//使框架窗口中的每一个视图接收它们的OnInitialIpdate
}
★//视图的OnUpdate虚函数重写
void CMdiView::OnUpdate( CView* pSender, LPARAM lHint, CObject* pHint )
{
//从文档里面拿数据，显示到视图中
CMdiDoc *pDc=(CMdiDoc *)GetDocument();
SetWindowText(pDc->m_strText);
}
★//文档视图数据改变响应消息实现函数
void CMdiView::OnEnChange()
{
CMdiDoc *pDoc=(CMdiDoc *)GetDocument();//获取这个视图的文档指针
GetWindowText(pDoc->m_strText);//将视图更新的数据保存到文档中
pDoc->UpdateAllViews(this);//文档通知每个和自己相关的视图调用自己的OnUpdate }
CMdiApp theApp;
BOOL CMdiApp::InitInstance(){
//创建多文档模板
CMultiDocTemplate *pTemplate=new CMultiDocTemplate(IDR_MDICHILD,
RUNTIME_CLASS(CMdiDoc),
RUNTIME_CLASS(CMDIChildWnd),
RUNTIME_CLASS(CMdiView)
);
//将文档模板保存进模板管理器
AddDocTemplate(pTemplate);
//创建和显示主框架窗口
CMainFrame *pFrame=new CMainFrame;
pFrame->LoadFrame(IDR_MDIMAIN);
m_pMainWnd=pFrame;
m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateWindow();
//新建文档(拥有几个OnFileNew就创建几个子窗口,注意OnFileNew函数是CWinApp的成员函数，添加菜单消息要在应用程序类中添加)
OnFileNew();
return TRUE;
}
文档视图架构
1 相关类
CWinApp-应用程序类
CFrameWnd-框架窗口类，应用于单文档
CMDIFrameWnd/CMDIChildWnd-主框架/子窗口,应用于多文档
CView-视图类，显示数据
CDocument-文档类，用于管理数据
CDocTemplate（抽象类）-文档模板类
两个子类：CSingleDocTemplate-单文档模板
CMultiDocTemplate-多文档模板
CDocManager-文档模板管理器
2 数据关系
CWinApp
|->m_pDocManager(CDocManager*)//文档模板管理器对象（AddDocTemplate函数中的，将创建好的模板给他）|->m_templateList(CDocTemplate List)(保存文档模板的链表，证明模板可以有多个)
|->CSingleDocTemplate-单文档模板, CMultiDocTemplate-多文档模板
★|->CRuntimeClass *m_pOnlyDoc ★|->m_docList(CDocument List)
|->CDocument
|->m_viewList(CcView List)
(保存视图地址) |->m_pMainWnd(CFreameWnd)
|->m_pMainWnd(CFrameWnd)
|->m_pViewActive(CView)
|->m_pDocument(CDocument)
|->m_viewList(Ciew的LIst)
3 创建对象
3.1 CWinApp查找模板，创建文档对象
3.2 OnFileNew中创建Frame对象
3.3 Frame的OnCreate中创建View
3.4 View的OnCreate中，View与Document相关联
4 命令消息相应顺序
CView->CDocument->Frame->App
MFC绘图
向导中生成消息
添加命令消息：Ctrl+W 类向导对话框查找ID->选择命令消息格式双击（COMMAND）->确定->编辑消息即可添加标准消息：在所要添加的类右键->Add windows message Hander->选择消息，双击加载->Add and Edit 删除一行：Ctrl+L
1绘图相关
CDC相关-绘图设备-被绘图的地方（纸）CGdiObject相关-绘图对象-用什么绘制（笔）
2 CDC相关
2.1 CDC父类是CObject，封装了HDC绘图句柄和相应的API
2.2子类
CPaintDC-封装类BeginPaint和EndPaint函数，只能在WM_PAINT的消息处理函数中使用
绘图范围是窗口的客户区。
CClinetDC-封装了客户区DC,使用范围比CPaintDC更广一些
绘图范围也是窗口的客户区
CWindowDC-封装了窗口的DC,绘图范围是整个窗口
CMetaFileDC-封装了Windows图源文件的处理。
和别的绘图保存点坐标不一样，它保存的是绘图命令（Moveto，画矩形，画圆等）
2.3 CDC相关类使用
★创建CDC
virtual BOOL CreateDC( LPCTSTR lpszDriverName, //打印设备的类型（显示器，打印机等）
LPCTSTR lpszDeviceName, //设备名称
LPCTSTR lpszOutput,
const void* lpInitData //和设备相关的一些参数
);
例：
void CMFC_DCView::OnCdc()
{
CDC dc;
dc.CreateDC("DISPLAY",NULL,NULL,NULL);//创建设备
dc.TextOut(100,100,"CDC");//输出字符（CDC是显示器坐标为基准）
dc.DeleteDC();//即使不去删除设备，析构的时候也会删除
}
★创建CClinetDC
例：
void CMFC_DCView::OnCclinetdc()
{
CClientDC dc(this);//构造绘图设备对象（有参数，需要传入窗口指针）
dc.TextOut(0,0,"CClientDC-客户区");
dc.MoveTo(100,100);//线的起点
dc.LineTo(200,200);//线的终点
}
★创建CWindowDC
例：
void CMFC_DCView::OnCwindowdc()
{
CWindowDC dc(AfxGetMainWnd());//创建绘图设备（AfxGetMainWnd()得到窗口的句柄）dc.TextOut(0,0,"CWindowDC-窗口");
}
★创建CMetaFileDC
void CMFC_DCView::OnCmetafiledc()
{
CMetaFileDC dcMEta;
dcMEta.Create("C:\\huai.dat");//创建对象（就是创建将保存命令的文件）
dcMEta.TextOut(100,200,"CMetaFileDC");//绘图
dcMEta.Rectangle(CRect(100,100,300,300));
HMETAFILE hMetaFile=dcMEta.Close();//保存这些命令进文件返回绘图设备通用句柄
CClientDC dc(this);//创建在当前客户区绘图的对象
dc.PlayMetaFile(hMetaFile);//显示文件绘图命令
DeleteMetaFile(hMetaFile);//删除句柄
}
3 CGdiObject相关
3.1相关子类
CBitmap-位图CBrush-画刷CFont-字体CPalette-调色板CPen-画笔
CRgn-基于基本的集合图形，构建复杂的集合图形
3.2 CRgn使用
3.2.1创建CPen
例：void CMFC_DCView::OnPen()
{
CClientDC dc(this);//创建绘图设备
CPen pen(PS_SOLID,10,RGB(230,0,0));//创建画笔对象（线型，线宽，颜色）
CPen *pOldPen=(CPen *)dc.SelectObject(&pen);//将创建好的对象选入设备
dc.Rectangle(50,50,100,100);//绘图
dc.SelectObject(pOldPen);//还回绘图对象
pen.DeleteObject();//删除对象
}
3.2.2创建CBrush—（可以直接用刷子，也可以刷位图等）
例：void CMFC_DCView::OnBrush()
{
CClientDC dc(this); //创建绘图设备
CBitmap bmp;//创建位图对象
bmp.LoadBitmap(IDB_BITMAP1);//用位图对象加载位图资源
CBrush brush(&bmp);//创建绘制此位图的画刷对象
//CBrush brush(HS_BDIAGONAL,RGB(0,255,255));//画刷有很多种实现，查msdn
CBrush *pOldBrush=dc.SelectObject(&brush) ;//将创建好的对象选入设备
dc.Rectangle(50,50,100,100);//绘图
dc.SelectObject(pOldBrush); //还回绘图对象
brush.DeleteObject();//删除对象
}
3.2.3 创建CFont
例：void CMFC_DCView::OnCfont()
{
CClientDC dc(this); //创建绘图设备
CFont font; //创建字体对象
font.CreatePointFont(1000,"宋体");//一号字用10,1000代表10号子,后面字体的名称
CFont *pOldFont=dc.SelectObject(&font);
dc.TextOut(100,100,"hello");
dc.SelectObject(pOldFont);
font.DeleteObject();
}
3.2.4 创建CBitmap
例：void CMFC_DCView::OnCbitmap()
{
CClientDC dc(this); //创建绘图设备
CBitmap bmp;//创建位图对象
//制定位置加载位图资源（也可即在别的资源）
//应用程序句柄，资源位置，什么资源，宽，高，加载选项，返回句柄
HANDLE x=LoadImage(NULL,"C:\\huai.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
bmp.Attach(x);//使位图对象和位图资源相关联
//bmp.LoadBitmap(IDB_BITMAP1);//也可直接加载创建的位图
//创建相匹配的DC
CDC dcBmp;
dcBmp.CreateCompatibleDC(&dc);
CBitmap *pBmpOld=(CBitmap *)dcBmp.SelectObject(&bmp);//吧位图对象绑定到相匹配的DC
dc.StretchBlt(100,100,200,200,&dcBmp,0,0,200,200,SRCCOPY);//绘图
dcBmp.SelectObject(&pBmpOld);
bmp.DeleteObject();
dcBmp.DeleteDC();
}
3.2.5 创建CRgn
例1：void CMFC_DCView::OnCrgn()
{
CRgn rgn1;//创建混合图形中的第一个
rgn1.CreateEllipticRgn(150,150,450,450);//绘制一
CRgn rgn2;//创建混合图像中第二个
rgn2.CreateEllipticRgn(350,150,650,450);
https://www.doczj.com/doc/d119193409.html,bineRgn(&rgn1,&rgn2,RGN_DIFF);//通过一二两个图像组合出新的图像保存进一
CClientDC dc(this);
CBrush brush(HS_DIAGCROSS,RGB(200,100,100));
dc.FillRgn(&rgn1,&brush);//用画刷填充区域
CBrush brushFrame(RGB(200,100,100));
dc.FrameRgn(&rgn1,&brushFrame,3,3);//用画刷画边框（后两个指定宽度）}
例2：void CMFCGdiObjectView::OnCrgn()
{
CRgn rgnYaling;
rgnYaling.CreateRectRgn(200,200,500,250);
CRgn rgnLeft;
rgnLeft.CreateEllipticRgn(150,150,300,300);
CRgn rgnRight;
rgnRight.CreateEllipticRgn(450,150,600,300);
https://www.doczj.com/doc/d119193409.html,bineRgn(&rgnYaling,&rgnLeft,RGN_OR);
https://www.doczj.com/doc/d119193409.html,bineRgn(&rgnYaling,&rgnRight,RGN_OR);
CRgn rgnLeftHole;
rgnLeftHole.CreateEllipticRgn(180,180,270,270);
CRgn rgnRightHole;
rgnRightHole.CreateEllipticRgn(480,180,570,270);
https://www.doczj.com/doc/d119193409.html,bineRgn(&rgnYaling,&rgnLeftHole,RGN_DIFF);
https://www.doczj.com/doc/d119193409.html,bineRgn(&rgnYaling,&rgnRightHole,RGN_DIFF);
CClientDC dc(this);
CBrush brush(HS_DIAGCROSS,RGB(100,100,200));
dc.FillRgn(&rgnYaling,&brush);
CBrush brushFrame(RGB(200,100,100));
dc.FrameRgn(&rgnYaling,&brushFrame,3,3);
AfxGetMainWnd()->SetWindowRgn(rgnYaling,TRUE);
}
鼠标绘图例子
1 建立菜单，将需要绘制图案保存在菜单项里面，逐个添加命令消息和处理函数。
2 鼠标绘图，所以和鼠标的按下和弹起坐标有关，应该通过消息获取，添加标准消息和处理函数。
3 在类中还应建立一个保存坐标的成员对象CPoint m_ptBegin; 和选择绘制什么图案的对象UINT m_nDrawType;。
//菜单命令消息响应函数
void CMFCDrawView::OnDarwLine()
{
m_nDrawType=1;
}
void CMFCDrawView::OnDrawRect()
{
m_nDrawType=2;
}
void CMFCDrawView::OnDrawElipic()
{
m_nDrawType=3;
}
//按下鼠标左键消息处理函数
void CMFCDrawView::OnLButtonDown(UINT nFlags, CPoint point)
{
m_ptBegin=point;//获得按下坐标进对象
CView::OnLButtonDown(nFlags, point);//向导自加代码
}
//鼠标左键弹起消息处理函数
void CMFCDrawView::OnLButtonUp(UINT nFlags, CPoint point)
{
CClientDC dc(this);//创建绘图设备
//获得预定义绘图对象句柄（在此定义空心刷，没有背景色）
HBRUSH hBrush=(HBRUSH)GetStockObject(NULL_BRUSH);
CBrush *pNullBrush=CBrush::FromHandle(hBrush);//获得画刷指针
CBrush *pOldBrush=(CBrush *)dc.SelectObject(pNullBrush);//将画刷绑定到绘图设备//根据消息判断到底画什么图案
switch(m_nDrawType)
{
case 1:
dc.MoveTo(m_ptBegin);
dc.LineTo(point);
break;
case 2:
dc.Rectangle(CRect(m_ptBegin,point));
break;
case 3:
dc.Ellipse(CRect(m_ptBegin,point));
break;
default:
break;
}
dc.SelectObject(pOldBrush);//还回系统默认的笔
CView::OnLButtonUp(nFlags, point);//向导自加代码
}
MFC中实现多文档(转)2007-12-27 21:21 MDI (Multiple Document Interface) 是Windows 界面的一种规范，它建立多个窗口来浏览文档数据，如Windows 中的Program Manager 等都是按MDI 规范实现的。在实际工程软件开发中，许多程序员将其作为一种实现多窗口的标准方法。微软基础类库(Microsoft Foundation Class Library, 简称MFC 库), 是微软公司为方便Windows 程序开发所提供的一个功能强大的通用类库。MFC 的核心是以类的形式封装了大量Windows API。在可视化编程语言VC++ 下应用MFC 是目前开发Windows 程序最方便的途径之一。VC++ 提供的各种开发工具如AppWizard、ClassWizard 和App Studio, 可以建立起具备基本功能的Windows 框架程序(Framework)。而程序员所需要做的工作就是将自己特有的代码填入到框架程序中去，从而极大地减少了用户界面编程的工作量，加快了开发速度。关于MDI 的标准开发方法可参考一般的Windows 编程书籍，本文将介绍利用MFC 实现MDI 界面。 MFC 2.0 以上版本支持“文档/ 浏览视窗”(Document/View) 结构模式。由文档负责管理数据，浏览视窗负责数据显示及与用户的交互，从而实现了数据与界面的分离，使整个程序设计更具规范化、模块化。MFC 中，“文档”由类CDocument 及其派生类实现( 简称Doc 类)；“浏览视窗”由类CView 及其派生类实现 ( 简称View 类)。二者都包含于应用程序的框架窗口中，并由其管理。使用单文档时，框架窗口由类CFrameWnd 及其派生类实现；使用多文档时，框架窗口是利用类CMDIFrameWnd 和CMDIChildWnd 实现。由文档模板将文档、浏览窗口和框架窗口三者联系起来。 当程序员在App Wizard 的Option 选项中选择 Multiple Document Interface 时，MFC 构架程序(Framework) 将自动生成实现MDI 基本功能的代码。类CMDIFrameWnd 负责整个应用程序的主框架窗口；类CMDIChildWnd 实现MDI 的子窗口框架，它不带菜单项，而与主框架窗口共享菜单。主框架窗口依据当前激活的子窗口自动更换菜单项。CView 则负责MDI 子窗口客户区中显示的具体内容。例如，App Wizard 的以M01 为Project 名建立的构架程序(framework) 中包括一些基本类：主框架窗口CMainFrame：派生自CMDIFrameWnd；文档CM01Doc ：派生自CDocument；浏览窗口CM01View：派生自CView；其中CM01Doc、CM01View 和CMDIChildWnd 由多文档模板CMultiDocTemplate 联系在一起。在CM01App::InitInstance() 函数中代码如下： BOOL CM01App::InitInstance() { ...... CMultiDocTemplate* pDocTemplate;
文档对象：是用来保存数据的。 视图对象：是用来显示和编辑数据的。 应用程序框架：框架是用来管理不同文档显示界面的。例如你有一个数据网格显示界面，还有一个图形显示界面，它们的数据可能都来自你的文档，但是视图不同，怎么办用框架。为什么不用视图？为的是把界面管理独立的拿出来。 文档模板：MFC把文档/视图/框架视为一体，只要你创建文档/视图框架结构的程序，必定会为你创建这三个类。这个工作在在应用程序初始化时完成，如下： [cpp]view plaincopy 1.BOOL CMyHtmlApp::InitInstance() 2.{ 3. CSingleDocTemplate* pDocTemplate; 4. pDocTemplate = new CSingleDocTemplate( 5. IDR_MAINFRAME, 6. RUNTIME_CLASS(CMyHtmlDoc), 7. RUNTIME_CLASS(CMainFrame), // main SDI frame window 8. RUNTIME_CLASS(CMyHtmlView)); 9. AddDocTemplate(pDocTemplate); 10. } 单文档：就是一次只能打开一个文件，和你的文档类型支持的多少无关。你完全可 以做一个单文档的支持所有图象格式的程序，只不过它一次只能打开一个文档罢了。 多文档：就是你可以打开多个文件，和文档类型也无关。你也可以作一个可以同时 打开多个文档的程序，但它只支持一种文档类型。 何时需要文档/视图框架结构？
首先你可以不使用文档视图这种框架结构，即便是在MFC中。你可以在你需要的时候选择使用这种方式。你可以完成一个只有视图没有文档的程序，例如一个基于对话框的应用。 哪什么时候需要呢？ 当你想将你的数据层和界面层分开的时候。 通常我们对数据的操作放在文档类中，例如存取，打开，关闭。在这里你可以尽情的对你的数据进行操作，如果你需要，在对数据进行了改变后，对视图做一下更新，那么程序会将你对数据所做的改变呈现给你的程序的用户。由此可见视图的作用就是提供一个用户和数据之间进行数据交换的界面，它的作用就是在需要的时候显示数据，并在需要的时候提供输入界面。当用户输入后实际的数据操作工作是由文档类来做的。 那框架类有在做什么呢？ 框架类是为了便于管理你的文档类和视图类而存在的。通常我们的操作都是通过视图窗口完成，消息由视图进行接收并且进行处理。所以消息映射定义一般在视图中。 但如果一个应用同时拥有多个视而当前活动视没有对消息进行处理则消息会发往框架窗口。另外框架窗口可以方便的处理非窗口消息。 再来说一边典型的单文档程序的生成过程（不完整，只挑有用的） ? ?1、CwinApp对象被建立，这个对象是全局的且只能有一个，名字叫theApp。 这时你可以完成一些工作，例如对注册表的操作，（如果你想写一个不修改注册表的软件，需要在这里做写工作） 2、在InitInstance()函数中创建文档模板，文档模板以CruntimClass静态成员 指针做构造参数。 3、执行MFC框架默认的命令行参数。命令行参数有很多其中之一是，Cmd1 它会创建一个新文件。（如果没有命令行参数则执行默认的ID_FILE_NEW） 4、文档模板的实例根据三个类的动态创建信息创建出文档、视图、框架。 5、对文档、视图、框架进行初始化。
MFC是一个编程框架 MFC中的各种类结合起来构成了一个应用程序框架，它的目的就是让程序员在此基础上来建立Windows下的应用程序。MFC框架定义了应用程序的轮廓，并提供了用户接口的标准实现方法。AppWizard可以用来生成初步的框架文件。资源编辑器用于帮助直观的设计用户接口。ClassWizard用来协助添加代码到框架文件，最后，通过类库实现了应用程序特定的逻辑。 MFC提供了一个Windows应用程序开发模式，对程序的控制主要是由MFC框架完成的。而且MFC也完成了大部分的功能，预定义或实现了许多事件和消息处理。框架或者由其本身处理事件，不依赖程序员的代码，或者调用程序员的代码来处理应用程序特定的事件。 1.S DI生成 1.步骤dxq2009 首先，打开VC++6.0开发环境，然后，选择”File”菜单中的“New”子菜单，在弹出的对话框中选择“MFC AppWizard（exe）”项并在“Progect name”编辑框中输入合适的工程名字Simple1，如图，它的意思是创建一个基于MFC的应用，接着进入正式的创建过程，MFC 应用程序的创建过程有6步（基于对话框）或者6步（SDI或者MDI），下面首先介绍SDI 应用的创建过程。 （1）第一步用于选择应用的结构以及语言等。如图1，首先确定应用是否需要Doc/View Architecture Support支持，因为不使用该结构的应用不支持从磁盘文件打开文档，也没有派生于类CWnd的窗口客户区。上面3个单选按钮用于确定创建的应用类型，
包括单文档，多文档，对话框，这里选择第一个。然后从资源列表框选择应用所使用的语言种类，单击“Next”。 图1 （2）第二步为用用程序选择4项数据库支持选项之一：如图2.如果选择了数据库支持，那么单击“Data Source”按钮，选择外部的数据库表项，一般按默认即可，单击“Next”。 图2 （3）第三步选择希望包含在应用中的复合文档支持项，同时判定是否启用标准的ActiveX 资源，以及是否为应用的菜单条添加额外的自动化命令等，如图4，一般安默认，单击“Next”
1.1 MFC 文档视图结构程序结构总揽 当我们使用MFC AppWizard 生成一个MFC 程序，选用所有默认的设置（当然也是Multiple Documents ，本文讨论主要基于Multiple Documents ，对于Single Document 情况仅以简单表述提及，皆因后者和前者很多相似相同之处，但前者更为复杂，并且更加常用。），假设你的程序名称为A ，则你会得到CMainFrame 、CChildFrame 、CAboutDlg 、CADoc 、CAView 、CAApp 6 个类（Single Document 仅少一个CChildFrame 类，其余均同）。这些类的具体含义将在后面给出，这里先要给出一个MFC 支持文档视图结构程序（以下简称App ）的主要组成： 一个App （对应类CAApp ）可以包含多个文档模版（CDocTemplate ），但是MFC AppWizard （无论是SDI 还是MDI ）都只是默认生成一个。但是在实际开发中一个文档模版不够，需要自己手工添加（在后面实际项目例子提供示例）。这个结构是通过MFC 中CWinApp 的成员变量CDocManager* m_pDocManager 实现的，我们的CAApp 正是继承自MFC 提供的CWinApp 类。 CDocManager 类则拥有一个指针链表CPtrList m_templateList 来维护这些文档模版。这些文档模版都是在CAApp ：：InitInstance （）中通过AddDocTemplate(pDocTemplate) 。 CDocTemplate 拥有3 个成员变量，分别保存着Document 、View 、Frame 的CRuntimeClass 指针，另外持有成员变量m_nIDResource ，用来指定这个Document 显示时候采用的菜单资源。这4 份数据都在CAApp ：：InitInstance （）中CDocTemplate 的构造函数中指定。在Document 中拥有一个回指CDocTemplate 的指针（m_pDocTemplate ）。 一个文档可以有多个视图，由Document 中成员变量CPtrList m_ViewList 维护。 CFrameWnd 拥有一个成员变量CView* m_pActiveView 指向当前活动的View 。 CView 中拥有一个成员变量CDocument* m_pDocument 指向该视图相 关的Document 。 [ 注解] ：①MFC SDI/MDI 程序默认都默认生成了一个文档模版，并将这个文档模版Add 到其文档模版的链表中，由于这是MFC 默认提供的，因此这个文档模版会被插入到文档模版的第一个位置，而MFC 也是通过这个文档模版的特定位置可以确定的。默认情况下，当我们点击File （Open ）/ File （New ）的时候，这个文档模版会被启用。 除了侯捷先生在《深入浅出MFC 中列出的以上的深入分析，我们还应该（很大程度上更加重要）掌握以下的关于MFC SDI/MDI 的知识：
MFC总结（一）：MFC中文件操作、查找与选择总结（1） 本文主要涉及以下几个方面，均为在MFC编程中较为常用的：CFile操作、CArchive操作、如何选择文件和文件夹、如何查找文件、获取当前目录、_access函数等。 (一）使用CFile类操作文件 CFile类在MFC的文件操作中应该是最常用的了。主要的成员函数有Open、Close、Write、Read、Seek、SeekToEnd、GetLength、GetPosition，具体用法见MSDN。 （1）文件打开操作： 文件打开有两种方式，一种是先定义类对象，在用Open函数打开；一种是在定义类对象时传入文件名和打开方式。分别如下 CFile file; if(!file.Open(lpszFileName, nOpenFlags )) return; 或 CFile file(lpszFileName, nOpenFlags); （2）文件打开方式： 文件打开方式，即上述nOpenFlags的值主要由一些宏定义的值组合而成，具体见MSDN，常用的有如下几种： A. CFile::modeCreate | CFile::modeNoTruncate |CFile::modeWrite，以写文件的方式打开，如果文件不存在，则新建文件，否则打开已有文件进行写入操作，此时不会清空原有文件； B. 将上述CFile::modeWrite更换为CFile::modeRead或者 CFile::modeReadWrite可实现读操作或者同时读写。 （3）判断文件结束 判断文件是否结束，没有结束则继续读取，否则关闭退出。这点在编程时常用。对于CFile常用的判断文件结束的方法是： while(file.GetPosition() < file.GetLength()) { //文件未结束 //Add code .... } （4）值得注意的几点： A. 当文件名中包含路径时，要注意使用\\，如C:\\MyFile.DAT，在Unicode下时，需要使用_T("C:\\MyFile.DAT")； B. 采用（2）中A方式写文件时，注意使用file.SeekToEnd()将文件指针移至文件尾，再写入，否则会覆盖已有的数据，这点经常被很多初学者忽视；
MFC 课程特点 一个编程框架的学习 基于框架，添加和修改代码 代码的调试技巧断点调试。call stack 查看函数的调用关系 由理论到实践实践到理解理论的过程 课程连续性比较强 掌握MFC课程的知识点之外还需要掌握代码的调试技巧阅读别人的代码 day01 一 MFC的概念 Microsoft Foundation Classes 微软基础类库 包括两个方面：
1 一个编程框架，快速开发。 2 庞大的类库，可以满足我们基本的编程要求 二 MFC发展历程 Borland公司-----菲利普斯.康和安德鲁斯.海尔斯伯格在1983年创建，以编译器起家的。早在doc年代，Borland c/c++ , microsoft c/c++ 在win3.x 年代， Borland c/c++ 3.0/3.1 92 年 visual c++ 1.0 开始挖墙角，Borland公司主要开发人员（尤金.王）离职， Microsoft 与 borland 的编译器之争。 visual c++ 2.0 集成的MFC3.0 主要面向32位的程序开发。 visual c++4.0 集成的MFC的4.0 加入了对internet的支持 visual c++5.0 集成ATL库。 98年9月份推出visual c++ 6.0 对类库及界面做了优化。 安德鲁斯.海尔斯伯格 c#语言之父。
vs2010，集成MFC 10.0 三、展开讲解MFC 1 MFC类的介绍继承关系的介绍 1.1 CObject类及派生类 1.1.1 CObject类—MFC的顶层父类，定义了MFC的一些基本特性和机制，例如 运行时类信息动态创建和序列化等。 1.1.2 CCmdTarget类----在该类中，对命令消息做了相应的处理（例如点击菜单工具栏产生wm_command消息。）如果一个类处理命令消息，继承自CCmdTarget。 1.1.3 CWinApp类—应用程序类，几乎所有的MFC程序都要使用该类。贯穿了整个程序的始终。 1.1.4 CDocTemplate类，文档模板类。在该类的子类中分别定义了单文档模板和多文档模板。 1.1.5 CDocument 文档类 ----管理数据。包括数据的存储和加载等。
MFC文档视图结构 MFC（Microsoft Foundation Classes）是微软公司开发的一个用于Windows平台的C++类库，用于简化Windows桌面应用程序的开发。MFC 提供了各种类和函数，用于实现常见的视图结构，其中包括文档视图结构。 文档视图结构是MFC中用于实现文档和视图之间交互的一种架构。它 主要由文档类（CDocument）、视图类（CView）和框架窗口类（CFrameWnd）组成。 文档类（CDocument）是表示应用程序中特定文档的类，它负责管理 文档的数据和状态。每个文档类通常只处理一个特定类型的文档，如文本 文档、图像文档等。文档类中的成员函数包括OpenDocument、SaveDocument等，用于打开和保存文档。文档类还可以包含数据成员， 用于存储文档的内容。 视图类（CView）是用户界面的一部分，用于显示和修改文档的内容。每个文档类通常都有一个对应的视图类。视图类中的成员函数包括OnDraw、OnUpdate等，用于绘制文档的内容和响应用户输入。视图类还 可以处理鼠标、键盘等事件。 框架窗口类（CFrameWnd）是应用程序的主窗口，负责创建和管理文 档和视图。每个应用程序通常只有一个框架窗口类。框架窗口类中的成员 函数包括OnCreate、OnSize等，用于处理窗口的创建、大小调整等事件。框架窗口类还可以包含菜单、工具栏等用户界面元素。 文档视图结构的工作流程通常如下： 1.应用程序启动时，框架窗口类创建，并创建一个文档类和一个视图类。
2.框架窗口类创建菜单、工具栏等用户界面元素，同时将文档和视图 关联起来。 3.用户可以通过菜单、工具栏等用户界面元素打开、保存文档，触发 相应的文档类成员函数。 4.文档类根据用户的操作，读取或写入文件的数据，更新文档的内容。 5. 视图类接收到文档类的数据变化通知（通过OnUpdate函数），根 据最新的数据，重新绘制文档的内容。 6.用户可以通过鼠标、键盘等与视图进行交互，触发相应的视图类成 员函数。 7.视图类根据用户的操作，修改文档的数据，通过文档类更新文档的 内容。 通过文档视图结构，可以将应用程序的逻辑分离，使得文档和视图可 以独立开发和测试。文档类和视图类各自负责处理不同的逻辑，减少了耦 合性，提高了代码的可维护性和复用性。 总结起来，MFC文档视图结构是一种用于实现文档和视图之间交互的 架构。它由文档类、视图类和框架窗口类组成，通过各自的成员函数和事 件处理函数，实现了文档和视图的打开、保存、绘制和交互等功能。文档 视图结构能够提高应用程序的可维护性和复用性，是MFC开发的重要概念 之一
第2章文档/视图结构应用程序 2.0 知识要点 1. 文档/视图结构的思想是将数据的管理与显示分离，其中文档用于管理应用程序的数据，而视图是用户界面，用于显示、打印文档中的数据，并管理与用户的交互。 2. SDI具有文档/视图结构的应用程序框架，该框架包括应用程序类、窗口框架类、文档类和视图类，编程的任务是在文档类和视图类中添加适当的代码。其中文档类中一个重要的成员函数是OnNewDocument()，用户在此添加代码完成对数据的初始化；而视图类中最重要的成员函数是OnDraw()，通过在该函数中添加代码实现窗口内容的输出。 3. 通过介绍几种SDI结构的典型应用程序来了解其结构及设计方法，典型应用包括： •利用画笔、画刷等工具及位图处理的方法实现文字和图形的输出。 •利用定时器控件制作动画程序。 •对鼠标和键盘进行编程的基本方法。 •文件、字体、颜色等几种通用对话框的使用方法及自定义对话框的设计、调用方法。 •菜单的设计方法。 2.1 文档/视图结构 SDI 应用程序由 AppWizard 创建好后，即使没有编写一行代码，仍然可以运行，并且具有一个标准 Windows应用程序所需要的组成成份，程序员的工作就是往这个框架添加必要的代码。以下通过一个简单实例说明文档/视图结构应用程序的创建过程。 【例2-1】创建一个如图所示的应用程序，在窗口中显示一个矩形框，框中显示“同舟共济自强不息”。 假定本例的工程名为TEST，程序创建过程如下： （1）利用 AppWizard 创建一个 SDI 应用程序框架。 （2）文档类是存放数据的主要地方，本例在其中说明一个存放矩形框数据的 CRect 类对象 r 和一个存放字符串的 CString 对象s，方法为： 在工作区的“ ClassView ”中，双击 CTESTDoc 类，在该类代码中添加如下代码：
mfc类库结构 MFC（Microsoft Foundation Class）类库是一种用于开发Windows 应用程序的C++类库。它提供了一系列的类和函数，用于简化Windows应用程序的开发过程。通过使用MFC类库，开发人员可以更加高效地创建用户界面、处理用户输入、管理窗口和控件等。MFC类库的结构非常清晰，可以分为以下几个主要部分：应用程序类、文档类、视图类和框架类。 首先是应用程序类，它是整个应用程序的入口点。应用程序类负责初始化应用程序的各个组件，包括创建主窗口、初始化菜单和工具栏等。它还处理应用程序的全局设置，如注册表项、命令行参数等。通过继承CWinApp类，开发人员可以轻松创建自己的应用程序类，并重写其中的方法以满足自己的需求。 接下来是文档类，它负责处理应用程序的数据。文档类通常对应着应用程序中的一个文档，可以是一个文本文件、一个图像文件或者其他类型的数据。文档类负责打开、保存和关闭文档，以及处理文档的各种操作，如插入、删除和修改数据等。通过继承CDocument 类，开发人员可以创建自己的文档类，并添加自定义的数据处理逻辑。 然后是视图类，它负责显示应用程序的用户界面。视图类可以是一个窗口、一个对话框或者一个控件等。视图类负责处理用户输入，
响应用户的操作，并更新界面显示。通过继承CView类，开发人员可以创建自己的视图类，并实现自定义的界面逻辑。 最后是框架类，它起到连接应用程序各个组件的作用。框架类管理应用程序的各个窗口和控件，处理消息传递和事件处理等。通过继承CFrameWnd类，开发人员可以创建自己的框架类，并添加自定义的界面和逻辑。 除了以上几个主要部分，MFC类库还提供了许多辅助类和函数，用于处理常见的任务，如文件操作、数据库访问、绘图和打印等。开发人员可以根据自己的需求使用这些类和函数，从而更快地完成应用程序的开发。 MFC类库是一种功能强大的工具，可以帮助开发人员快速开发Windows应用程序。它的清晰结构和丰富的功能使得开发人员可以更加高效地实现自己的想法，并为用户提供优秀的用户体验。无论是从界面设计到数据处理，MFC类库都为开发人员提供了丰富的工具和组件，使得开发过程更加简单和高效。
MFC单文档窗体类的创建过程 MFC（Microsoft Foundation Classes）是微软公司提供的一种面向对象的程序开发工具，用于简化Windows操作系统的应用程序开发。MFC 提供了丰富的类库和框架，使开发人员能够更快速地创建Windows程序。在MFC中，窗体类是常用的一种类，用于创建窗体应用程序。本文将详细介绍MFC单文档窗体类的创建过程。 在MFC中，创建单文档窗体类的过程可以分为以下几个步骤： 1.创建一个新的MFC应用程序项目 首先，需要使用MFC应用程序向导创建一个新的MFC应用程序项目。打开Visual Studio，选择“文件”->“新建”->“项目”，在“新建项目”对话框中选择“Visual C++”->“MFC”->“MFC应用程序”，并填写项目名称和保存路径，点击“确定”按钮。接下来，按照向导的指引，选择“单文档”应用程序类型，并点击“完成”按钮。 2.添加对话框资源 在MFC应用程序项目创建完成后，需要添加对话框资源。在资源视图中，选择“添加”->“资源”->“对话框”，在弹出的对话框中输入对话框名称，并点击“确定”按钮。此时，会自动生成一个对话框资源，可以在其中添加所需的控件。 3.创建窗体类 在MFC应用程序项目中，会自动生成一个CWinApp类和一个CMainFrame类。我们需要创建一个新的窗体类，用于承载对话框资源。在Solution Explorer中，右击“源文件”->“添加”->“类”，在弹出
的“添加类”对话框中选择“MFC”->“MFC类”->“单文档视图”，并填写类名称和保存路径，点击“添加”按钮。此时，会自动生成一个新的窗体类，可以在其中添加处理逻辑。 4.修改窗体类代码 打开新生成的窗体类的头文件和源文件，可以看到自动生成的代码。在头文件中，需要包含所需的头文件，并声明成员变量和成员函数。在源文件中，需要实现窗体类的构造函数、析构函数和其他成员函数。 在构造函数中，需要调用基类的构造函数，并通过Create函数创建对话框，并调用LoadDialog函数加载对话框资源。在析构函数中，需要调用DestroyWindow函数销毁对话框。在其他成员函数中，可以添加自定义的处理逻辑。 5.修改主框架类代码 打开CMainFrame类的头文件和源文件，在源文件中，可以看到自动生成的代码。在构造函数中，会创建窗体类的实例，并通过AddView函数将窗体类添加到主框架类中。在OnCreate函数中，需要创建窗体类的实例，并通过SetActiveView函数将其设置为活动视图。 6.修改应用程序类代码 打开CWinApp类的源文件，在InitInstance函数中，需要创建主框架类的实例，并通过Run函数启动应用程序。 7.编译和运行程序 修改完代码后，可以通过编译和运行程序来查看效果。在菜单栏上选择“调试”->“开始调试”，或者按下F5键，编译并运行程序。此时，
MFC中实现多文档 MFC（Microsoft Foundation Class）是用于Microsoft Windows操作系统的应用程序框架。多文档是指在一个应用程序中同时打开和管理多个文档的能力。下面是如何在MFC中实现多文档的步骤： 1.创建一个新的MFC应用程序项目： - 在Visual Studio中选择“文件”>“新建”>“项目”。 - 在“左侧导航栏”中选择“Visual C++”>“MFC”。 -选择“MFC应用程序”并点击“下一步”。 -输入项目名称，并选择存储位置，然后点击“下一步”。 -选择“多文档”应用程序类型，并确保“使用多文档视图”选中，然后点击“完成”。 2.修改文档类： - 打开“xxxDoc.h”文件（xxx为你的应用程序名称）。 -在文档类声明中添加一个成员变量来保存文档的数据。 3.修改视图类： - 打开“xxxView.h”文件。 -在视图类声明中添加用户界面控件（如按钮、菜单等）来实现文档的交互操作。 -在视图类声明中，添加成员变量来保存文档数据的指针。
- 在视图类的实现文件中，重写OnInitialUpdate(函数，初始化视图。 4.修改主框架窗口类： - 打开“MainFrm.h”文件。 -在主框架窗口类声明中，添加成员变量来保存文档视图的指针。 - 在主框架窗口类的实现文件中，重写OnCreateClient(函数，创建并管理多个文档视图的布局。 5.添加命令处理函数： - 打开“xxxView.cpp”文件。 -在视图类的实现文件中，添加命令处理函数，例如保存文档、打开新文档等。 6.调试和测试： -编译并运行应用程序。 -打开多个文档，观察每个文档的窗口布局和视图。 -测试各种文档操作，如保存、打开、关闭等。 以上是使用MFC框架实现多文档的基本步骤。根据你的具体需求，你可以进一步定制和扩展多文档功能，例如添加更多自定义的菜单和工具栏选项、实现文档之间的数据交互等。
MFC常用类介绍 MFC（Microsoft Foundation Class）是一套基于Windows操作系统 的应用程序框架，它是微软公司为开发Windows应用程序而提供的一系列 标准类库。MFC提供了许多常用的类，用于简化Windows应用程序的开发 过程。下面将介绍一些常用的MFC类。 1. CWinApp类：CWinApp是MFC应用程序框架的核心类，是一个应用 程序对象的封装。它提供了应用程序的初始化和退出等功能，以及消息循 环的处理。 2. CFrameWnd类：CFrameWnd是MFC中的主窗口类，用于创建和管理 主窗口。它提供了对主窗口的操作，例如创建、显示、隐藏、最大化、最 小化等。 3. CDocument类：CDocument是MFC中的文档类，用于管理文档对象。它提供了打开、保存、关闭、撤消、重做等文档操作的功能，并与视图类 和框架类进行协作。 4. CView类：CView是MFC中的视图类，用于显示和操作文档数据。 它负责将文档数据显示在主窗口中，并处理用户输入的操作。 5. CDialog类：CDialog是MFC中的对话框类，用于创建和管理对话框。它提供了对话框的操作，例如创建、显示、隐藏、控件消息处理等。 6. CButton类：CButton是MFC中的按钮类，用于创建和管理按钮控件。它提供了按钮的属性设置和按钮消息的处理。 8. CListBox类：CListBox是MFC中的列表框类，用于创建和管理列 表框控件。它提供了列表框的属性设置和列表项的添加、删除等功能。
11. CMenu类：CMenu是MFC中的菜单类，用于创建和管理菜单。它提供了菜单的属性设置、菜单项的添加、删除、禁用、启用等功能。 12. CStatusBar类：CStatusBar是MFC中的状态栏类，用于创建和管理状态栏。它提供了状态栏的属性设置和状态信息的显示。 13. CToolBar类：CToolBar是MFC中的工具栏类，用于创建和管理工具栏。它提供了工具栏的属性设置和工具按钮的添加、删除等功能。 14. CProgressCtrl类：CProgressCtrl是MFC中的进度条类，用于创建和管理进度条控件。它提供了进度条的属性设置和进度值的更新。 15. CTreeCtrl类：CTreeCtrl是MFC中的树形控件类，用于创建和管理树形控件。它提供了树形结构的构建、节点的添加、删除、展开、折叠等功能。 以上只是MFC中的一部分常用类，还有很多其他的类可供使用。这些类的使用可以大大简化Windows应用程序的开发过程，提高开发效率，并且有助于保持应用程序的一致性和可维护性。
mfc单文档例子 以下是一个简单的MFC单文档（SDI）应用程序的示例： 1. 首先，创建一个新的MFC应用程序项目。在Visual Studio中，选择“文件”菜单，然后选择“新建”->“项目”。在“新建项目”对话框中，选择“MFC应用程序”，然后输入项目名称和位置，并单击“确定”。 2. 在“MFC应用程序向导”中，选择“单文档”作为应用程序类型，并单击“完成”按钮。 3. 在生成的代码中，找到`CMainFrame`类。这是应用程序的主窗口类。 4. 在`CMainFrame`类的`OnCreateClient`函数中，添加以下代码： ```cpp void CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext pContext) { // 创建视图窗口 m_(_T("My View"), WS_CHILD WS_VISIBLE WS_BORDER WS_HSCROLL WS_VSCROLL, CRect(0, 0, 800, 600), this, ID_VIEW_WIN);
} ``` 5. 在`CMainFrame`类的`OnCreate`函数中，添加以下代码： ```cpp BOOL CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) { if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1; // 创建工具栏和状态栏 CToolBarCtrl tb; CRect rect(0, 0, 800, 24); (WS_CHILD WS_VISIBLE CBRS_TOP CBRS_GRIPPER CBRS_TOOLTIPS CBRS_FLYBY, rect, this, ID_VIEW_TB); m_(WS_CHILD WS_VISIBLE CBRS_TOP CBRS_GRIPPER CBRS_TOOLTIPS CBRS_FLYBY, rect, this, ID_VIEW_TB); m_(this); m_(0, ID_VIEW_STATUSBAR, SBPS_STRETCH, 0); m_(1, ID_VIEW_STATUSBAR2, SBPS_STRETCH, 0);
Visual C++ 中操纵 MS Word 123 分享到：新浪微博腾讯微博更多-- 收藏 发布日期： 2004-07-09 11:26 浏览次数： 1181次 标签： COM 文章评分： 5.0 操作： 下载源文件打印 杨老师 称号：未设置 简介：... 文章概要： 使用VC编程来操纵Office。你可以实现诸如：Word文件打印、传送数据到Word文档、发送E-MAIL、自动产生表格、Excel数据统计、圆饼图，直方图显示、自动报表生成、播放幻灯、doc，txt，HTML，rtf 文件转换、中文简繁体转换、拼音或笔画排序......只要是Office能够实现的功能，都可以在你写的程序中调用。仔细阅读下面的说明，并下载源文件进行参考，你就可以一步一步地掌握这个技术。祝朋友们学习快乐。 使用VC编程来操纵Office。你可以实现诸如：Word文件打印、传送数据到Word文档、发送E-MAIL、自动产生表格、Excel数据统计、圆饼图，直方图显示、自动报表生成、播放幻灯、doc，txt，HTML，rtf文件转换、中文简繁体转换、拼音或笔画排序......只要是Office 能够实现的功能，都可以在你写的程序中调用。仔细阅读下面的说明，并下载源文件进行参考，你就可以一步一步地掌握这个技术。祝朋友们学习快乐。 一、概念 Microsoft 的Office 产品中，都提供了OLE Automation 自动化程序的接口。如果你使用VB，VBA 和Script 脚本调用Office 功能的话，其实比使用VC 调用要简单的多。比如在WORD 中，调出菜单“工具(T)\宏(M)\录制新宏(R)”，这时候它开始记录你在WORD 中
MFC程序也有一个WinMain函数，这个函数是我们在编译链接的时候由链接器将WinMain函数链接进来的。这个函数在APPMODUL.CPP中。 带有Afx的属于应用程序框架类的函数，应用程序框架是辅助我们生成应用程序的框架模型，这个框架模型把很多类或者类与类之间做了一个有机的集成提供给我们，我们可以根据框架模型提供的类库来设计我们自己的应用程序，Af即Application frame 看看这些类如何和我们WinMain函数关联到一起的？ CmainFrame的名字是不会变的，其它的都是C+工程名+App/Doc/View命名。 class CTestApp : public CwinApp，可以看到CtestApp是从CwinApp派生出来的。当我们双击CtestApp这个类时，我们可以看到VC++6.0上面显示我们进入了Test.h头文件中，当把CtestApp展开时，然后双击任何一个函数名，包括构造函数名，析构函数名…我们可以看到VC++6.0上面显示我们进入了Test.cpp源文件中。且这种情况和我们直接从Fileview 资源卡中直接进入相应的头文件和源文件是一样的效果。其它类也是相似的操作进入头文件和源文件。 不管是全局变量还是在全局对象CTestApp theApp;，它们都是在程序运行之前，也就是在入口函数WinMain函数加载之前，就已经为它们分配好了内存空间，作为全局函数，就要调用构造函数创建内存空间。所以是先运行全局对象CTestApp theApp，调用它的构造函数，然后才运行WinMain。 为什么要定义一个全局对象呢？为什么要让它在WinMain之前完成呢？全局对象theApp又有什么作用？CtestApp是从CwinApp派生出来的，theApp是应用程序对象，是一个全局对象，每一个MFC程序当中有且仅有一个从CwinApp派生出来的类，也只能有一个应用程序类实例化的对象，它就表示了我们应用程序本身。全局的对象theApp会导致构造函数的调用，CtestApp是从CwinApp派生出来的，当一个子类的构造函数调用之前先要构造父类，所以导致了CwinApp构造函数的调用，CwinApp是谁写的呢？是微软提供给我们的，那么这个派生类就和微软提供给我们的基类就关联起来了，在CwinApp中对程序和初始化的工作在CwinApp的构造函数中就完成了。 CWinApp::CWinApp(LPCTSTR lpszAppName)，CwinApp的构造函数带有一个参数，而继承它的CtestApp确没有参数，这是为什么呢？因为它在CwinApp进行函数原型声明时有一个默认值，CWinApp(LPCTSTR lpszAppName = NULL); CWinApp::CWinApp(LPCTSTR lpszAppName) { if (lpszAppName != NULL) m_pszAppName = _tcsdup(lpszAppName); else m_pszAppName = NULL; // initialize CWinThread state AFX_MODULE_STATE* pModuleState = _AFX_CMDTARGET_GETSTATE(); AFX_MODULE_THREAD_STATE* pThreadState = pModuleState->m_thread; ASSERT(AfxGetThread() == NULL); pThreadState->m_pCurrentWinThread = this; 因为this指针是指向对象本身，所以这个this指针是指向子类CtestApp的全局对象theApp。 当基类CwinApp实例化完成之后，子类CtestApp实例化完成之后，全局对象就有了内存空间，全局对象定义好了之后，接下来就该执行我们WinMain函数了。在main函数中进
MFC hierarchy chart（类库列表） MFC与Win32 1 win32：函数，使用API一步一步搭建应用程序。（常使用FileView操作） 2 MFC编程：实现仍然调用API函数，但是是用类封装API函数，使用向导自动生成应 用程序框架。（常使用ClassView操作） 2.1需要掌握的技能 2.1.1断点调试 2.1.2堆栈调用的查看 MFC课程内容 1 MFC：MFC的六大机制，文档式架构，常用的MFC类，（10--12）。 2 COM（组件对象模型）：COM的原理和应用（6）。 3 ADO/Socket：MFC访问数据库以及一些简单的网络编程。 MFC应用程序编程 1 MFC的历史：92（VC1）98（VC6）………………………. 2 MFC库基础： 2.1 MFC库，微软基础类库。封装了Windows应用程序编程的各种API以及相关机制 的C++类库 3 类库的相关头文件件 ★afx-application framework（应用程序框架x） 3.1
MFC应用程序的类型 1 支持MFC的控制台应用程序（控制台的第四个选项） 1.1 多了一个CWinApp（应用程序类，封装类应用程序启动过沉重所涉及到得相 关信息）的全局对象（必须有，而且只能有一个） 1.2主函数中多了一个AfxWinInit函数，初始化MFC库中的相关信息 2 MFC库程序 2.1 MFC支持的静态库 2.2 MFC支持的动态库 2.2.1 MFC规则库（shared MFC DLL）-可以被各种应用程序调用（非MFC程 序，没有MFC类也可以调用） ★还是有一个CWinApp派生的CMFC_DLLApp类对象 2.2.2 MFC扩展库（using shared MFC DLL）-只能被MFC库所编写的应用程 序所调用（对原有的MFC类扩展） ★DllMain主函数只能被MFC程序调用 3 MFC应用程序-----（注意看父类，子类名字可能不一样） 3.1单文档视图应用程序 ★CWinApp 应用程序类 ★CAboutDlg（对话框-生成关于窗口-和框架没有任何关系） ★CMainFrame（父类是：CFrameWnd）（应用程序主框架窗口类-生成应用程 序的主框架-负责各个对象的协调工作） ★CDocument（它是父类）（文档类-看不到的很重要-管理数据） ★CView（它是父类）（视图类-显示数据并和用户进行交互） ★CSingleDocApp（父类是CWinApp）-（使用前面的3个类来创建对象） 3.2多文档视图架构 ★CWinApp 应用程序类 ★CAboutDlg（对话框-生成关于窗口-和框架没有任何关系） ★CView（它是父类）（视图类-显示数据并和用户进行交互） ★CDocument（它是父类）（文档类-看不到的很重要-管理数据） ★CMDIChildWnd（子框架窗口类，父类） ★CMDIFrameWnd（主框架窗口类，父类） 我们看到的子窗体其实是★CView和★CMDIChildWnd叠加的 3.3基于对话框的应用程序 ★CWinApp 应用程序类 ★CDialog（对话框窗口类） ★★m_pMainWnd保存主窗口地址 DoModal 显示对话框
深入了解MFC中的文挡/视结构 Visual C++ 5.0 以其功能强大、用户界面友好而倍受程序员们的青睐。但是，在当前的Microsoft 基本类库4.2 版本中，大约有将近200 个类，数千个函数，加之Microsoft 公司隐藏了一些技术细节，使得人们深入学习MFC变得十分困难。 MFC的AppWizard可以生成三种类型的应用程序：基于对话框的应用、单文档应用（SDI）和多文档应用（MDI）。前两者的结构较简单，本文不再赘叙。笔者拟从MFC中的文档/视结构入手，分析一些函数的流程，并解决编制MDI 应用程序过程中的一些常见问题。 （一）、了解文档/视结构 MFC应用程序模型历经多年以有了相当大的发展。有一个时期，它只是个使用应用程序对象和主窗口对象的简单模型。在这个模型中，应用程序的数据作为成员变量保持在框架窗口类中，在框架窗口的客户区中，该数据被提交显示器。随着MFC2。0的问世，一种应用程序结构的新方式----MFC文档/视结构出现了。在这种结构中，CFrameWnd繁重的任务被委派给几个不同类，实现了数据存储和显示的分离。一般情况下，采用文档/视结构的应用程序至少应由以下对象组成： 。应用程序是一个CwinApp派生对象，它充当全部应用程序的容器。应用程序沿消息映射网络分配消息给它的所有子程序。 。框架窗口是一CFrmeWnd派生对象。 。文档是一个CDocument派生对象，它存储应用程序的数据，并把这些信息提供给应用程序的其余部分。 。视窗是Cview派生对象，它与其父框架窗口用户区对齐。视窗接受用户对应用程序的输入并显示相关联的文档数据。 通常，应用程序数据存在于简单模型中的框架窗口中。在文档/视方式中，该数据移入称为document 的独立数据对象。当然，文档不一定是文字，文档是可以表现应用程序使用的数据集的抽象术语。而用户输入处理及图形输出功能从框架窗口转向视图。单独的视窗完全遮蔽框架窗口的客户区，这意味着即使程序员直接绘画至框架窗口的客户区，视图仍遮蔽绘画，在屏幕上不出现任何信息。所以输出必须通过视图。框架窗口仅仅是个视图容器。 CDocument类对文档的建立及归档提供支持并提供应用程序用于控制其数据的接口。MDI应用程序可以处理多个类型的文档，每个类型的文档拥有一个相关联的文档模板对象。文档对象驻留在场景后面，提供由视图对象显示的信息。文档至少有一个相关联的视图。视图只能与一个文档相关联。 在文档/视方式中，对象的建立是由文档模板来管理的，它是CDocTemplate派生对象，建立并维护框架窗口，文档及视。 MFC调用命令处理程序以响应发生在应用程序中的事件。命令发送的优先级是： 活动的视图->框架窗口->文档->应用程序->默认窗口过程(DefWindowsProc) 总之，在文档/视方式中，文档和视是分离的，即：文档用于保存数据，而视是用来显示这些数据。文档模板维护它们之间的关西。这种文档/视结构在开发大型软件项目时特别有用。