华丽的界面
VC6.0实现逆向操作并防止界面闪烁
在系统编程中，使用VC是很好的开发工具，而对于一个成熟的系统，几乎都需要有回退与重做功能（即文档操作逆向化）以防止用户误操作或不合适的操作，从而提高系统的友好性和可操作性。在很多VC技术文章中均提到过这个问题，不过总存在着界面闪烁或不完全可逆．
本文提出一种对系统编程可实现完全可逆并防止闪屏的方法．
一、基本原理
要对文档进行回退重做功能，要做两方面的工作，一方面要保留删除的文档（在操作过程中，删除的文档资料一定能够保留），另一方面，系统必须能够记录进行文档操作的全过程及每个操作过程的参数。为了保留历史操作，所有数据非常占用内存空间，这就是一些系统只能进行有限次退步逆向操作的原因。本文提出的方法建立如下存储机制：建一个临时文件储存数据模拟堆栈，进行一次操作时将相关操作数据入栈．回退一次将相关数据弹出栈，重做一次又依据相关数据重新恢复原有数据．它的好处是在回退和重做时只入一次栈即申请一次内存。
堆栈的数据排放如图：
// Undo、Redo 数据排放示意图（m_UndoDataList）
//
// ====
// |###| }
// |###| }
// |###| } ----->> Redo 数据
// |###| }
// |###| }
// |\\\| }
// |\\\| }
// |\\\| }
// |\\\| } --->> Undo 数据（Undo数据弹出后将转换为Redo数据）
// |\\\| }
// |\\\| }
// =====
// Undo数据栈
二、实现文档回退重做的引擎
建一文档逆向化堆栈引擎．主要代码为：
1.建立临时文件．（m_TempPath可以按照某种规则形成路径）
if(m_File.Open((LPCTSTR)m_TempPath, CFile::modeCreate|CFile::modeReadWrite|CFile::shareExclusive))
{
m_File.SeekToBegin();
m_UndoCount = 0; file://当前可重做的步数
m_RedoCount = 0; file://当前可回退的步数
｝
2．保存回退数据模块．
// 保存一个Undo数据块（由用户提供）
int CRedoUndoEngine::PushData(
LPVOID pData,
// 由用户提供的内存块首地址，其中含有用户定义的待保存的数据。
// （注：如果函数成功，此内存块将会被本函数释放，因此，该内存块必须是用::GlobalAlloc()函数分配的）
DWORD size, // pData指向的内存块尺寸
DWORD param1,
// 用户提供的对该内存块的说明参数，含义由用户定义
DWORD param2,
// 用户提供的对该内存块的说明参数，含义由用户定义
int *pIndex
// 如果成功，本函数将返回压入的Undo块在栈中的索引值。
如果不需要此返回值，可用NULL作为参数
)
{
// 删除Redo数据
if (m_RedoCount)
{
while(m_RedoCount--)
delete (LPISEEUNDOINFO)m_UndoDataList.RemoveTail();
m_RedoCount = 0;
}
// 填写Undo数据的索引信息(lpISeeUndoInfo为一个保存数据的结构体)
lpISeeUndoInfo->m_index = m_UndoCount; // 索引
lpISeeUndoInfo->m_UserData1 = param1;
// 用户定义的标识性数据1
lpISeeUndoInfo->m_UserData2 = param2;
// 用户定义的标识性数据2
lpISeeUndoInfo->m_DataSize = size; // 用户的Undo数据块尺寸
lpISeeUndoInfo->m_FilePosition =
_get_current_overwrite_pos();
// 加新的Undo数据到Undo栈的尾部
m_UndoDataList.AddTail((void*)lpISeeUndoInfo);
// 将用户的Undo数据写入临时文件
m_File.Seek(lpISeeUndoInfo->m_FilePosition, CFile::begin);
m_File.Write((const void *)pData, size);
并使Undo块计数加1
m_UndoCount++;
// 此时用户传过来的数据块已经无用，删除！
::GlobalFree(pData);
return 1;
}
3.弹出重做数据模块．
// 弹出一个Redo数据块
int CIUndoEngine::RedoData(
LPVOID *ppData, // 用于接收本函数返回的含有最近一个Redo数据的内存块首地址的指针
// （注：此内存块交由调用者释放，使用::GlobalFree()函数）
DWORD *pSize, // ppData内存块的尺寸(in byte) ，如果不需要此数据可用NULL作为参数
DWORD *pParam1, // 返回用户对该Redo块的附加信息，如果不需要此数据可用NULL作为参数
DWORD *pParam2, // 返回用户对该Redo块的附加信息，如果不需要此数据可用NULL作为参数
int *pIndex // 返回本Redo块的索引，如果不需要此数据可用NULL作为参数
)
{
if (!m_RedoCount)
return 0;
// 锁定待弹出的Redo索引信息块的地址
POSITION pos = m_UndoDataList.FindIndex(m_UndoCount);
ASSERT(pos);
LPISEEUNDOINFO lpISeeUndoInfo= (LPISEEUNDOINFO)m_UndoDataList.GetAt(pos);
ASSERT(lpISeeUndoInfo);
ASSERT(lpISeeUndoInfo->m_index == m_UndoCount);
if (!(*ppData))
return -1;
// 读出用户保存在临时文件中的Undo数据（也即Redo数据）
m_File.Seek((LONG)lpISeeUndoInfo->m_FilePosition, CFile::begin);
m_File.Read(*ppData, lpISeeUndoInfo->m_DataSize);
m_UndoCount++; // 可用Undo数据块个数加1
m_RedoCount--; // 可用Redo数据块个数减1
if (pSize)
*pSize = lpISeeUndoInfo->m_DataSize;
if (pParam1)
*pParam1= lpISeeUndoInfo->m_UserData1;
if (pParam2)
*pParam2= lpISeeUndoInfo->m_UserData2;
if (pIndex)
*pIndex = m_RedoCount;// 注：此处的索引是Redo的索引，而不是Undo的
return 1;
}
由这个文档逆向化操作引擎，可以获得当前改动的文档的数据，并根据改动的数据更新视图，而不刷新没有更改数据的视图.从而防止了闪烁的产生．
三、简单开发实例
下面以我们开发服装CAD过程中加入的回退重做功能（文档逆向化）说明之。
1.定义回退类型
#define REUNDO_MOV 0x0001 file://衣片移动回退重做
#define REUNDO_SEL 0x0002 file://衣片选择回退重做
……….
2.保存某个操作之前和之后的数据(以衣片移动回退重做为例)
//----------申请内存----------------------//
int nByte = 4*sizeof(DWORD);
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);
LPVOID pData = (LPVOID) GlobalLock(hMem);
file://-----保存衣片移动前后的位置读入内存------//用移动前后衣片的某个坐标点表示
memcpy((DWORD*)pData, &m_oldPoint, 2*sizeof(DWORD));
memcpy((DWORD*)pData+2,&point, 2*sizeof(DWORD));
file://--------数据入栈---------------------------------------//
m_pReUndoEngine->PushData(pData,//衣片m_pReUndoEngine文档逆向化引擎对象指针
nByte,//保存数据衣片字节数
REUNDO_MOV,//回退类型
NULL,NULL);
3.当回退操作事件触发时.
//弹出回退值
int nByte = m_pReUndoEngine->GetPopDataSize();
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);//申请内存
LPVOID pData = (LPVOID) GlobalLock(hMem);
DWORD undo_type;DWORD index;
m_pReUndoEngine->PopData(&pData,NULL,&undo_type,&index);
////////////////////////////////
switch(undo_type){//回退类型
case REUNDO_SEL:
SelUndo(pData,index,&dc);break;
case REUNDO_MOV:
MovUndo(pData);break;
…………
}
void CMarkView::MovUndo(LPVOID pData) 函数功能
{
CPoint pt1,pt2;
memcpy(&pt1,(DWORD*)pData,8);
memcpy(&pt2,(DWORD*)pData+2,8);
…….由pt1 和pt2可以求出位移量,从而恢复原衣片的位置.
}
4.当重做操作事件触发时
//弹出回退值
int nByte = m_pReUndoEngine->GetRedoDataSize();
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);//申请内存
LPVOID pData = (LPVOID) GlobalLock(hMem);
DWORD undo_type;DWORD index;
m_pReUndoEngine->RedoData(&pData,NULL,&undo_type,&index);
switch(undo_type){//回退类型
case REUNDO_SEL:
SelRedo(pData,index,&dc,nByte);break;
case REUNDO_MOV:
MovRedo(pData); break;
…………
}
函数MovRedo(pData)与MovUndo(pData)类似就不多说了.
由3,4可以看出,在回退与重做过程中,只是保存和取出操作对象已变化的过程,使编程者很容易实现高效率刷新与充分节约存储空间.
小结
在系统编程中,文档的回退与重做几乎是必不可少的,本文提出了一种思路,即对文档的各种操作分解,并把每种操作下变化的对象的数据值保存于临时文件(栈)中,在回退与重做时根据变化量很容易恢复操作之前状态或重做, 避免了有些系统(保存全部文档数据)占用大量内存空间而只能有限次文档逆向化,并且全部刷新而闪烁,破坏了界面的友好性。
怎样在一个Pane中显示多种View？
在MS Windows 中，一个窗口可以分割成若干个子窗口，每一个子窗口称作一个窗片(pane)，每个窗片可以独立控制，这给界面设计提供了很大的方便。
---- 利用VC 可以很方便地实现分割窗口。分割的方法有两种：动态和静态。动态分割时可以根据用户的需要分割成数目不同的窗片，但所有窗片的属性和父窗口都是一样的；而静态分割的窗片的数目在程序中指定，运行时是固定的，但每个窗片可以有各自不同类型的视(View)，因此其使用范围更为广泛。本文所讨论的问题仅限于静态分割。
---- 窗片中视的类型大多是在主窗口的创建过程中指定的。这也就意味着，一个窗片虽然可以显示任意类型的视，但是这种类型一旦确定，在程序运行过程中就难以改变。
---- 一、我要的是这样的！
---- 但是我们有时确实需要改变一个窗片所显示的视的类型，也就是说，需要让一个窗片显示多种类型的视。例如一个窗口被分割成两部分，一边是命令窗口，另一边是工作窗口，根据命令窗口中发出的不同命令，需要变换不同的工作类型，这就需要工作窗口中能够显示多种类型的视窗，那么，如何做到这一点呢？
---- 二、你可以这样做！
---- 从图1 中可以看到，本程序共有三个视类，分别是：
---- ? 命令视类CCmdView：用来控制右边窗片中不同视的显示；
---- ? 选项按钮视类CRdiView：显示在右窗片中的选项视类；
---- ? 检查按钮视类CChkView：显示在右窗片中的检查视类。
---- 这三个视类都是CFormView 的子类。
---- 下面我们来看如何在右窗片内进行两类视间的切换。实际上，由视A 切换到视B 的原理很简单，那就是：
---- 1. 从窗片中删除视A；
---- 2. 往窗片中添加视B。
---- 步骤1 的实现非常简单，仅用一条语句即可：
---- m_wndSplitter.DeleteView(0, 1);
---- 但它是必不可少的，因为你不能让一个窗片同时包含两个视。我本来希望往一个窗片中添加新的视时，VC 会自动将原来的视删簦墒撬桓伞?br>
---- 我们来看如何实现步骤2，当一个窗片是空的时候，怎样往里面添加一个视呢？其实这样的功能在程序里我们已经用过了，看下面的语句：
BOOL CMainFrame::OnCreateClient
(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
……
if (!m_wndSplitter.CreateView(0, 0,
pContext->m_pNe ewClass,
size,
pContext))
……
}
---- 是的，用的就是CSplitterWnd::CreateView()，要注意的是它共有五个参数，其中前两个用来指定分割窗口的窗片，第三个用来指定视的类型，第四个指定视的大小。最后的一个我们暂时用不上，用空值NULL 就可以了。
---- 这样我们就可以编写视切换的代码了。因为视切换要操纵m_wndSplitter，而它是主窗口的成员，因此切换过程最好设计为主窗口的成员函数。但是切换命令是CCmdView 接受的，因而可以让CCmdView 接受到视更改消息后，将消息传给主窗口，由主窗口完成视更改。具体的代码是这样的：
---- 命令视类中的消息映射：
BEGIN_MESSAGE_MAP(CCmdView, CFormView)
……
ON_BN_CLICKED(IDC_CHECK, OnSwitchToCheckView)
ON_BN_CLICKED(IDC_RADIO, OnSwitchToRadioView)
……
END_MESSAGE_MAP()
命令视类中的消息响应：
void CCmdView::OnSwitchToCheckView()
{
AfxGetApp()->m_pMainWnd->
SendMessage(WM_COMMAND, ID_CHECK);
}
void CCmdView::OnSwitchToRadioView()
{
AfxGetApp()->m_pMainWnd->
SendMessage(WM_COMMAND, ID_RADIO);
}
主窗口中的消息映射：
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
……
ON_COMMAND(ID_CHECK, OnSwitchToCheckView)
ON_COMMAND(ID_RADIO, OnSwitchToRadioView)
……
END_MESSAGE_MAP()
主窗口中的消息响应：
void CMainFrame::OnSwitchToCheckView()
{
m_wndSplitter.DeleteView(0, 1);
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CChkView),
CSize(0, 0),
NULL);
m_wndSplitter.RecalcLayout();
}
void CMainFrame::OnSwitchToRadioView()
{
m_wndSplitter.DeleteView(0, 1);
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CRdiView),
CSize(0, 0),
NULL);
m_wndSplitter.RecalcLayout();
}
---- 好啦，运行一下这个程序，感觉是否不错？看来大功告成了，可是……
---- 三、还有一个问题
---- 在运行我们辛辛苦苦编出来的程序时，回头看看VC 的调试窗口，你会发现有很多行这样的话：
---- Create view without document.
---- 这是说我们创建了视，可是没有相应的文档。好在这只是警告信息，不是什么错误，如果你不需要相应的文档，就完全不用去管它。可是，VC 中一种很重要的结构就是文档- 视结构，利用这种结构，对数据操纵起来非常方便。如果需要建立与视相对应的文档，应该怎么办呢？
---- 这就涉及到VC 中文档- 视结构的知识，不过不用怕麻烦，与本文有关的就只有这么两点而已：
---- 1. 利用VC 创建的应用程序一般都会管理一些文档模板(Document Template)，文档类和视类的对应关系就是在文档模板里描述的。
---- 2. 一个文档可以有多个视，创建视的时候，需要根据文档和视的对应关系，给出它所依附的文档。
---- 怎样实现上述第一点呢？
---- 首先建立相应的文档类：CRdiDoc 和CChkDoc。
---- 其次是定义相应的文档模板，这是应用类的成员变量。因为在别的类中要使用它们，我们将之定义为公共类型：
class CViewSwitcherApp : public CWinApp
{
……
public:
CSingleDocTemplate* m_pRdiDocTemplate;
CSingleDocTemplate* m_pChkDocTemplate;
……
}
然后创建这两个文档模板，并加入到模板列表中：
BOOL CViewSwitcherApp::InitInstance()
{
……
m_pRdiDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CRdiDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CRdiView));
AddDocTemplate(m_pRdiDocTemplate);
m_pChkDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CChkDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CChkView));
AddDocTemplate(m_pChkDocTemplate);
……
}
---- 至于第二点，是在创建视时完成的。还记得创建视的情况么？当时有一个叫做pCreateContext 的参数，我们将之置为空，这里就要用到它了。
---- pCreateContext 是一个指向被称作" 创建上下文"(CreateContext) 结构的指针，这个结构中保存一些与创建视相关的内容。在创建主窗口时，系统会构造这样一个结构，并将它作为参数传递到与创建视有关的函数中。但现在我们不创建主窗口，因此不得不自己构造这样一个结构。实际上，该结构中我们所要使用的字段只有三个：
---- 1. 新视所属的文档模板m_pNewDocTemplate；
---- 2. 新视的类型m_pNewViewClass；
---- 3. 新视所属的文档m_pCurrentDoc；
---- 其中仅有第三项需要新建，前两项都是已知的，只要指定即可。以切换到选项视为例，修改后的代码是：
void CMainFrame::OnSwitchToRadioView()
{
m_wndSplitter.DeleteView(0, 1);
CCreateContext createContext;
// 定义并初始化CreateContext
// 获取新视所属的文档模板
CSingleDocTemplate* pDocTemplate =
((CViewSwitcherApp*)AfxGetApp())-> m_pRdiDocTemplate;
// 创建新文档并初始化
CDocument* pDoc = pDocTemplate->CreateNewDocument();
pDoc->OnNewDocument();
// 设置CreateContext 相关字段
createContext.m_pNewViewClass = RUNTIME_CLASS(CChkView);
createContext.m_pCurrentDoc = pDoc;
createContext.m_pNewDocTemplate = pDocTemplate;
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CRdiView),
CSize(0, 0),
&createContext);
m_wndSplitter.RecalcLayout();
}
---- 四、最后的修改
---- 为了使这个程序更符合要求，我们还要做一些与更换视无关的修改。在这个程序中我们一共定义了三种类型的文档，程序启动时一般要新建一个文档开始工作，可是它不知道要选择哪一种，就弹出一个对话框来询问。而这是我们不希望看到的。修改的方法是不让VC 选择新文档类型，而我们指定创建哪一种类型的文档，即把CViewSwitcherApp::CViewSwitcherApp() 中的语句
---- if (!ProcessShellCommand(cmdInfo)) return FALSE;
---- 更改为
---- m_pDocTemplate->OpenDocumentFile(NULL)。
让基于对话框应用程序也有启动画面
用MFC的应用向导创建一个有主框架结构的应用程序，要使它具有启动画面是很简单的（下面会体验到），而要使一个基于对话框的应用程序也有启动画面则要费些事了，不过按以下笔者的方法则也是很容易的，我主要介绍方法，对画面仅采用默认情况，读者有兴趣可自己加工。
一、给一文档/视图应用程序做启动画面
（一） 建立一单文档/视图应用程序Hs
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Hs作为项目名并单击OK。在第一步中选中Single Document单选按钮，其它接受所有默认选项。
（二） 添加启动画面
当AppWizard完成，而且Visual C++打开项目的时候，从Project菜单中选择Add To Project，并单击位于次级菜单上的Comonents and Controls…，选择Splash screen组件，如图1(略)所示，单击Insert。接受所有的默认设置。
以上几步就建立起了一个有主框架结构的应用程序，并使它具有了启动画面。这是我们要做的准备工作已经完成。
二、给基于对话框应用程序做启动画面
(一）建立基于对话框的应用程序Spla
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Spla 作为项目名并单击OK。在第一步中选中Dialog Based单选按钮，其它接受所有默认选项。
(二）做启动画面
这里做启动画面如果仍采用前述用Gallery来插入是不行的，因为基于对话框的应用程序没有主框架。不过我们可以把上面建立起的启动画面文件移植过来，然后，对程序进行少许编程修改就行。请按照下面的步骤来做:
1、将Splash.cpp和Splash.h两个文件从Hs工程中拷贝到你的工程中。添加如下代码到CSplaApp的InitInstance()函数中。
#include "Splash.h"//头文件请放在开始位置
BOOL CSplaApp::InitInstance()
{
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
CSplashWnd::EnableSplashScreen
(cmdInfo.m_bShowSplash);
...
}
2、接下来，使用ClassWizard来添加OnCreate函数到你的对话框类中，并且添加如下代码： #include "Splash.h"//头文件请放在开始位置
int CSplaDlg::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
CSplashWnd::ShowSplashScreen(this);
…
}
3、将Splash16.bmp文件从Hs工程中拷贝到你的工程中 蚩猈orkspace的Resouce项，将Splash16.bmp插入。打开Properties将IDB_BITMAP1改为IDB_SPLASH，这个ID值只要和程序中一致起来就行，现在这样改最简便。
现在可以编译运行程序了，程序运行时出现如图2(略)的启动画面。这是默认的画面，你可以打开图形编辑器自己加工。如果你要改变启动画面的停留时间，就修改SetTime中的第二个参数，这里是750毫秒。
int CSplashWnd::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
// Set a timer to destroy the splash screen.
SetTimer(1, 750, NULL);
return 0;
}
一、给一文档/视图应用程序做启动画面
（一） 建立一单文档/视图应用程序Hs
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Hs作为项目名并单击OK。在第一步中选中Single Document单选按钮，其它接受所有默认选项。
（二） 添加启动画面
当AppWizard完成，而且Visual C++打开项目的时候，从Project菜单中选择Add To Project，并单击位于次级菜单上的Comonents and Controls…，选择Splash screen组件，如图1(略)所示，单击Insert。接受所有的默认设置。
以上几步就建立起了一个有主框架结构的应用程序，并使它具有了启动画面。这是我们要做的准备工作已经完成。
二、给基于对话框应用程序做启动画面
(一）建立基于对话框的应用程序Spla
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Spla 作为项目名并单击OK。在第一步中选中Dialog Based单选按钮，其它接受所有默认选项。
(二）做启动画面
这里做启动画面如果仍采用前述用Gallery来插入是不行的，因为基于对话框的应用程序没有主框架。不过我们可以把上面建立起的启动画面文件移植过来，然后，对程序进行少许编程修改就行。请按照下面的步骤来做:
1、将Splash.cpp和Splash.h两个文件从Hs工程中拷贝到你的工程中。添加如下代码到CSplaApp的InitInstance()函数中。
#include "Splash.h"//头文件请放在开始位置
BOOL CSplaApp::InitInstance()
{
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
CSplashWnd::EnableSplashScreen
(cmdInfo.m_bShowSplash);
...
}
2、接下来，使用ClassWizard来添加OnCreate函数到你的对话框类中，并且添加如下代码： #include "Splash.h"//头文件请放在开始位置
int CSplaDlg::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
CSplashWnd::ShowSplashScreen(this);
…
}
3、将Splash16.bmp文件从Hs工程中拷贝到你的工程中 蚩猈orkspace的Resouce项，将Splash16.bmp插入。打开Properties将IDB_BITMAP1改为IDB_SPLASH，这个ID值只要和程序中一致起来就行，现在这样改最简便。
现在可以编译运行程序了，程序运行时出现如图2(略)的启动画面。这是默认的画面，你可以打开图形编辑器自己加工。如果你要改变启动画面的停留时间，就修改SetTime中的第二个参数，这里是750毫秒。
int CSplashWnd::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
// Set a timer to destroy the splash screen.
SetTimer(1, 750, NULL);
return 0;
}
仔细查看了一下WIN32的API,发现其实创建任意形状的窗口其实也是很简单的，在VC中简单步骤如下：
当我们注册并创建了一个窗口类以后，我们在WM_CREATE消息中做如下处理:
(1)创建一个区域，使用CreatePolyonRgn，该函数创建一个多边形区域，（也可以使用其他方法如CreateRectRgn创建矩形区域），该函数返回一个HRGN的句柄；
(2)调用函数SetWindowRgn，即可设置窗口的形状。
补充说明的是，我们可以制作多个区域，然后用CombineRgn方法将多个区域合并为一个区域。这样我们就可以制作出更为丰富多采的窗口了。
VC编程实现IE风格的界面
使用过IE浏览器的朋友都知道IE界面上的扁平工具条、地址栏，扁平工具栏上的按钮正常状态下为扁平态，按钮上的图像为灰色，当鼠标放在按钮上时，按钮突起（这种状态称为手柄），并且其上的图像变得鲜艳醒目，一些按钮上还有汉字说明或标有小黑三角的下拉按钮，单击时显示下拉菜单，这些技术是怎么实现的呢，本文针对这些问题介绍了如何利用VC编程来实现它们。
IE风格的实现主要在主框架类的CMainFrame::OnCreate（）实现，它的主要思想如下：首先定义一个CReBar对象，用以作工具条、地址栏的容器，然后分别声明图像列表对象img用于存储工具栏上按钮的热点图像和正常状态下显示的图像。为了显示扁平工具栏，需要用CreateEx()函数创建CToolBar对象m_wndToolBar，用ModifyStyle（）函数将工具栏的风格设为扁平类型，你不能用CToolBar::Create（） 或 CToolBar:: SetBarStyle（）设置这种新风格。CToolBar 类不支持TBSTYLE_FLAT。要解决这个问题，必须绕过CToolBar类，使用CWnd::ModifyStyle（）。工具栏对象调用SetButtonInfo（）设置按钮的风格为TBSTYLE_DROPDOWN，就可以将工具栏按钮设置为附带有下拉按钮。至于按钮带有中文提示，用工具栏的SetButtonText（）就可以轻松实现了。下面是实现IE风格界面的部分代码和注释：
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
CReBar m_wndReBar;//声明CReBar对象
CImageList img;//声明图像列表对象
CString str;
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if (!m_wndReBar.Create(this))//创建CReBar对象
{
TRACE0("Failed to create rebar\n");
return -1; // fail to create
}
if (!m_wndToolBar.CreateEx(this))//创建工具条对象
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
// set up toolbar properties
m_wndToolBar.GetToolBarCtrl().SetButtonWidth(50, 150);
file://设置工具条上按钮的最大、最小尺寸
m_wndToolBar.GetToolBarCtrl().SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
file://工具条可以带有下拉按钮
img.Create(IDB_HOTTOOLBAR, 22, 0, RGB(255, 0, 255));
file://向图像列表装载热点图像资源，IDB_HOTTOOLBAR为热点图像资源ID
m_wndToolBar.GetToolBarCtrl().SetHotImageList(&img);//工具条装载热点图像
img.Detach();
img.Create(IDB_COLDTOOLBAR, 22, 0, RGB(255, 0, 255));
file://图象列表装载正常状态的图像资源，IDB_COLDTOOLBAR为图像资源ID
m_wndToolBar.GetToolBarCtrl().SetImageList(&img);//将图像装入工具条
img.Detach();
m_wndToolBar.ModifyStyle(0, TBSTYLE_FLAT | TBSTYLE_TRANSPARENT);
file://工具条为扁平风格
m_wndToolBar.SetButtons(NULL, 9);//工具条上有9个按钮
// set up each toolbar button
file://以下分别对九个按钮分别设置风格和按钮汉语提示
m_wndToolBar.SetButtonInfo(0, ID_BUTTON0, TBSTYLE_BUTTON, 0);
str.LoadString(IDS_ BUTTON0);
m_wndToolBar.SetButtonText(0, str);
m_wndToolBar.SetButtonInfo(1, ID_BUTTON1, TBSTYLE_BUTTON, 1);
str.LoadString(IDS_ BUTTON1);
m_wndToolBar.SetButtonText(1, str);
m_wndToolBar.SetButtonInfo(2, ID_BUTTON2, TBSTYLE_BUTTON, 2);
str.LoadString(IDS_ BUTTON2);
m_wndToolBar.SetButtonText(2, str);
m_wndToolBar.SetButtonInfo(3, ID_BUTTON3, TBSTYLE_BUTTON, 3);
str.LoadString(IDS_ BUTTON3);
m_wndToolBar.SetButtonText(3, str);
m_wndToolBar.SetButtonInfo(4, ID_BUTTON4, TBSTYLE_BUTTON, 4);
str.LoadString(IDS_ BUTTON4);
m_wndToolBar.SetButtonText(4, str);
m_wndToolBar.SetButtonInfo(5, ID_BUTTON5, TBSTYLE_BUTTON, 5);
str.LoadString(IDS_ BUTTON5);
m_wndToolBar.SetButtonText(5, str);
m_wndToolBar.SetButtonInfo(6, ID_BUTTON6, TBSTYLE_BUTTON | TBSTYLE_DROPDOWN, 6);
str.LoadString(IDS_ BUTTON6);
m_wndToolBar.SetButtonText(6, str);
m_wndToolBar.SetButtonInfo(7, ID_BUTTON7, TBSTYLE_BUTTON, 7);
str.LoadString(IDS_ BUTTON7);
m_wndToolBar.SetButtonText(7, str);
m_wndToolBar.SetButtonInfo(8,ID_BUTTON8, TBSTYLE_BUTTON | TBSTYLE_DROPDOWN, 8);
str.LoadString(IDS_ BUTTON8);
m_wndToolBar.SetButtonText(8, str);
file://重新调整按钮的尺寸
CRect rectToolBar;
m_wndToolBar.GetItemRect(0, &rectToolBar);//得到工具条第一个按钮的尺寸
m_wndToolBar.SetSizes(rectToolBar.Size(), CSize(30,20));
file://第一个参数为按钮尺寸，第二个参数为图像尺寸
file://创建一个组合框作为地址栏
if (!m_wndAddress.Create(CBS_DROPDOWN | WS_CHILD, CRect(0, 0, 200, 120), this, AFX_IDW_TOOLBAR + 1))
{
TRACE0("Failed to create combobox\n");
return -1; // fail to create
}
file://加入工具栏、地址栏
m_wndReBar.AddBar(&m_wndToolBar);
str.LoadString(IDS_ADDRESS);
m_wndReBar.AddBar(&m_wndAddress, str, NULL, RBBS_FIXEDBMP | RBBS_BREAK);
file://定义REBARBANDINFO对象,对工具条和地址栏设置理想尺寸
REBARBANDINFO rbbi;
rbbi.cbSize = sizeof(rbbi);
rbbi.fMask = RBBIM_CHILDSIZE | RBBIM_IDEALSIZE | RBBIM_SIZE;
rbbi.cxMinChild = rectToolBar.Width();
rbbi.cyMinChild = rectToolBar.Height();
rbbi.cx = rbbi.cxIdeal = rectToolBar.Width() * 9;
m_wndReBar.GetReBarCtrl().SetBandInfo(0, &rbbi);//设置工具栏尺寸
rbbi.cxMinChild = 0;
CRect rectAddress;
rbbi.fMask = RBBIM_CHILDSIZE | RBBIM_IDEALSIZE;
m_wndAddress.GetEditCtrl()->GetWindowRect(&rectAddress);
rbbi.cyMinChild = rectAddress.Height() + 10;
rbbi.cxIdeal = 200;
m_wndReBar.GetReBarCtrl().SetBandInfo(2, &rbbi);//设置地址栏尺寸
m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_FIXED);
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
return 0;
}
以上代码在Windows2000和Visual C++环境下编译通过，程序运行正常，有兴趣的朋友可以动手亲自实验一下。
VC限制窗口大小又一法
一般说见到的方法，，都是截获WM_GETMAXMININFO消息。
俺有另一经验可实现之。
由于一般窗口大小的改变，都是用户拖动窗口边框而造成的。所以，我们可以截获主窗口消息WM_NCHITTEST在其响应函数中判断CWnd::OnNcHitTest()的返回值是否为HTRIGHT,HTLEFT,HTTOP,HTBOTTOM四个值之一，如果是，说明用户此时已点击了四个边框之一，此时我们应该返回HTCLIENT.那么，鼠标的形状就不会变成水平或垂直的双向箭头，用户就不可能依靠拖动边框来改变窗口大小了。
另外，还应补上一个小漏洞，就是还要把系统菜单中的SC_SIZE去掉。
主程序之前的版权窗口
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
DWORD lTime;
try
{
Application->Initialize();
AboutBox=new TAboutBox(AboutBox);
AboutBox->BorderStyle=bsNone;
AboutBox->OKButton->Visible=false;
AboutBox->Height=185;
AboutBox->Show();
AboutBox->Update();
lTime=GetTickCount();
Application->CreateForm(__classid(TMainForm), &MainForm);
while((GetTickCount()-lTime) / 1000 < 3);
AboutBox->Hide();
AboutBox->Free();
Application->Run();
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
return 0;
}
VISUAL C++6.0在MDI主框架窗口中添加位图
笔者在开发项目时想在MDI程序中添加彩色位图以美化界面，也实验了几种方法，但都有一些小问题，经多方查找资料，终于圆满的实现了这种功能，现把我的实现方法介绍给大家。
首先要清楚对于一个MDI应用程序的主框架窗口来说包含一个特殊的子窗口称为MDICLIENT窗口，应用程序的主框架类中有一个成员变量m_hWndMDIClient 指的就是MDICLIENT窗口。MDICLIENT窗口负责管理主框架窗口的客户区，对MDI客户窗口编程有一定的难度。原因是MDIFrameWnd的客户区完全被MDICLIENT窗口覆盖掉了。这样，MDI主窗口类MDIFrameWnd的背景色和光标都不起作用。同时，微软并不支持将MDICLIENT窗口作为子类，MDICLIENT窗口只能使用标准的背景色和光标。所以，对MDI客户窗口编程不能象对普通窗口那样简单地重载WM_PAINT的消息处理函数。我们可以在主框架窗口截获关于MDICLIENT窗口的重画消息，然后加入自己设计的代码。我用PreTranslateMessage(MSG* pMsg) 截获MDI客户窗口WM_PAINT消息，在这个函数中向主框架窗口发送WM_PAINT消息，在该消息的处理函数中实现彩色位图的显示。我的具体实现如下：1、向程序添加256色彩色位图资源，命名为IDB_BITMAP1；2、用ClassWizard向主框架类添加函数CMainFrame::PreTranslateMessage(MSG* pMsg)；3、用ClassWizard向主框架类添加函数CMainFrame::OnPaint()；现给出两个函数的实现：
BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
// TODO: Add your specialized code here and/or call the base class
if(pMsg->hwnd==m_hWndMDIClient && pMsg->message==WM_PAINT)
PostMessage(WM_PAINT);
return CMDIFrameWnd::PreTranslateMessage(pMsg);
}
void CMainFrame::OnPaint()
{
CDC dc, memdc;
dc.m_hDC=::GetDC(this->m_hWndMDIClient);
CRect rect;
CBitmap bitmap;
BITMAP szbitmap;
bitmap.LoadBitmap(IDB_BITMAP1);
bitmap.GetObject(sizeof(BITMAP),&szbitmap);
CSize size(szbitmap.bmWidth,szbitmap.bmHeight);
memdc.CreateCompatibleDC(&dc);
CBitmap *oldbitmap=memdc.SelectObject(&bitmap);
GetClientRect(&rect);
StretchBlt(dc.m_hDC,0,0,rect.Width(),rect.Height(),
memdc.m_hDC,0,0,size.cx,size.cy,SRCCOPY);
memdc.SelectObject(oldbitmap);
memdc.DeleteDC();
dc.DeleteDC();
CMDIFrameWnd::OnPaint();
}
按上述步骤就可以实现在MDI程序中显示彩色位图了，我举的例子用的是256色位图，你也可以实现真彩色位图的显示，具体方法我就不多说了，有兴趣的朋友可以试一试。
华丽的界面
VC6.0实现逆向操作并防止界面闪烁
在系统编程中，使用VC是很好的开发工具，而对于一个成熟的系统，几乎都需要有回退与重做功能（即文档操作逆向化）以防止用户误操作或不合适的操作，从而提高系统的友好性和可操作性。在很多VC技术文章中均提到过这个问题，不过总存在着界面闪烁或不完全可逆．
本文提出一种对系统编程可实现完全可逆并防止闪屏的方法．
一、基本原理
要对文档进行回退重做功能，要做两方面的工作，一方面要保留删除的文档（在操作过程中，删除的文档资料一定能够保留），另一方面，系统必须能够记录进行文档操作的全过程及每个操作过程的参数。为了保留历史操作，所有数据非常占用内存空间，这就是一些系统只能进行有限次退步逆向操作的原因。本文提出的方法建立如下存储机制：建一个临时文件储存数据模拟堆栈，进行一次操作时将相关操作数据入栈．回退一次将相关数据弹出栈，重做一次又依据相关数据重新恢复原有数据．它的好处是在回退和重做时只入一次栈即申请一次内存。
堆栈的数据排放如图：
// Undo、Redo 数据排放示意图（m_UndoDataList）
//
// ====
// |###| }
// |###| }
// |###| } ----->> Redo 数据
// |###| }
// |###| }
// |\\\| }
// |\\\| }
// |\\\| }
// |\\\| } --->> Undo 数据（Undo数据弹出后将转换为Redo数据）
// |\\\| }
// |\\\| }
// =====
// Undo数据栈
二、实现文档回退重做的引擎
建一文档逆向化堆栈引擎．主要代码为：
1.建立临时文件．（m_TempPath可以按照某种规则形成路径）
if(m_File.Open((LPCTSTR)m_TempPath, CFile::modeCreate|CFile::modeReadWrite|CFile::shareExclusive))
{
m_File.SeekToBegin();
m_UndoCount = 0; file://当前可重做的步数
m_RedoCount = 0; file://当前可回退的步数
｝
2．保存回退数据模块．
// 保存一个Undo数据块（由用户提供）
int CRedoUndoEngine::PushData(
LPVOID pData,
// 由用户提供的内存块首地址，其中含有用户定义的待保存的数据。
// （注：如果函数成功，此内存块将会被本函数释放，因此，该内存块必须是用::GlobalAlloc()函数分配的）
DWORD size, // pData指向的内存块尺寸
DWORD param1,
// 用户提供的对该内存块的说明参数，含义由用户定义
DWORD param2,
// 用户提供的对该内存块的说明参数，含义由用户定义
int *pIndex
// 如果成功，本函数将返回压入的Undo块在栈中的索引值。
如果不需要此返回值，可用NULL作为参数
)
{
// 删除Redo数据
if (m_RedoCount)
{
while(m_RedoCount--)
delete (LPISEEUNDOINFO)m_UndoDataList.RemoveTail();
m_RedoCount = 0;
}
// 填写Undo数据的索引信息(lpISeeUndoInfo为一个保存数据的结构体)
lpISeeUndoInfo->m_index = m_UndoCount; // 索引
lpISeeUndoInfo->m_UserData1 = param1;
// 用户定义的标识性数据1
lpISeeUndoInfo->m_UserData2 = param2;
// 用户定义的标识性数据2
lpISeeUndoInfo->m_DataSize = size; // 用户的Undo数据块尺寸
lpISeeUndoInfo->m_FilePosition =
_get_current_overwrite_pos();
// 加新的Undo数据到Undo栈的尾部
m_UndoDataList.AddTail((void*)lpISeeUndoInfo);
// 将用户的Undo数据写入临时文件
m_File.Seek(lpISeeUndoInfo->m_FilePosition, CFile::begin);
m_File.Write((const void *)pData, size);
并使Undo块计数加1
m_UndoCount++;
// 此时用户传过来的数据块已经无用，删除！
::GlobalFree(pData);
return 1;
}
3.弹出重做数据模块．
// 弹出一个Redo数据块
int CIUndoEngine::RedoData(
LPVOID *ppData, // 用于接收本函数返回的含有最近一个Redo数据的内存块首地址的指针
// （注：此内存块交由调用者释放，使用::GlobalFree()函数）
DWORD *pSize, // ppData内存块的尺寸(in byte) ，如果不需要此数据可用NULL作为参数
DWORD *pParam1, // 返回用户对该Redo块的附加信息，如果不需要此数据可用NULL作为参数
DWORD *pParam2, // 返回用户对该Redo块的附加信息，如果不需要此数据可用NULL作为参数
int *pIndex // 返回本Redo块的索引，如果不需要此数据可用NULL作为参数
)
{
if (!m_RedoCount)
return 0;
// 锁定待弹出的Redo索引信息块的地址
POSITION pos = m_UndoDataList.FindIndex(m_UndoCount);
ASSERT(pos);
LPISEEUNDOINFO lpISeeUndoInfo= (LPISEEUNDOINFO)m_UndoDataList.GetAt(pos);
ASSERT(lpISeeUndoInfo);
ASSERT(lpISeeUndoInfo->m_index == m_UndoCount);
if (!(*ppData))
return -1;
// 读出用户保存在临时文件中的Undo数据（也即Redo数据）
m_File.Seek((LONG)lpISeeUndoInfo->m_FilePosition, CFile::begin);
m_File.Read(*ppData, lpISeeUndoInfo->m_DataSize);
m_UndoCount++; // 可用Undo数据块个数加1
m_RedoCount--; // 可用Redo数据块个数减1
if (pSize)
*pSize = lpISeeUndoInfo->m_DataSize;
if (pParam1)
*pParam1= lpISeeUndoInfo->m_UserData1;
if (pParam2)
*pParam2= lpISeeUndoInfo->m_UserData2;
if (pIndex)
*pIndex = m_RedoCount;// 注：此处的索引是Redo的索引，而不是Undo的
return 1;
}
由这个文档逆向化操作引擎，可以获得当前改动的文档的数据，并根据改动的数据更新视图，而不刷新没有更改数据的视图.从而防止了闪烁的产生．
三、简单开发实例
下面以我们开发服装CAD过程中加入的回退重做功能（文档逆向化）说明之。
1.定义回退类型
#define REUNDO_MOV 0x0001 file://衣片移动回退重做
#define REUNDO_SEL 0x0002 file://衣片选择回退重做
……….
2.保存某个操作之前和之后的数据(以衣片移动回退重做为例)
//----------申请内存----------------------//
int nByte = 4*sizeof(DWORD);
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);
LPVOID pData = (LPVOID) GlobalLock(hMem);
file://-----保存衣片移动前后的位置读入内存------//用移动前后衣片的某个坐标点表示
memcpy((DWORD*)pData, &m_oldPoint, 2*sizeof(DWORD));
memcpy((DWORD*)pData+2,&point, 2*sizeof(DWORD));
file://--------数据入栈---------------------------------------//
m_pReUndoEngine->PushData(pData,//衣片m_pReUndoEngine文档逆向化引擎对象指针
nByte,//保存数据衣片字节数
REUNDO_MOV,//回退类型
NULL,NULL);
3.当回退操作事件触发时.
//弹出回退值
int nByte = m_pReUndoEngine->GetPopDataSize();
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);//申请内存
LPVOID pData = (LPVOID) GlobalLock(hMem);
DWORD undo_type;DWORD index;
m_pReUndoEngine->PopData(&pData,NULL,&undo_type,&index);
////////////////////////////////
switch(undo_type){//回退类型
case REUNDO_SEL:
SelUndo(pData,index,&dc);break;
case REUNDO_MOV:
MovUndo(pData);break;
…………
}
void CMarkView::MovUndo(LPVOID pData) 函数功能
{
CPoint pt1,pt2;
memcpy(&pt1,(DWORD*)pData,8);
memcpy(&pt2,(DWORD*)pData+2,8);
…….由pt1 和pt2可以求出位移量,从而恢复原衣片的位置.
}
4.当重做操作事件触发时
//弹出回退值
int nByte = m_pReUndoEngine->GetRedoDataSize();
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);//申请内存
LPVOID pData = (LPVOID) GlobalLock(hMem);
DWORD undo_type;DWORD index;
m_pReUndoEngine->RedoData(&pData,NULL,&undo_type,&index);
switch(undo_type){//回退类型
case REUNDO_SEL:
SelRedo(pData,index,&dc,nByte);break;
case REUNDO_MOV:
MovRedo(pData); break;
…………
}
函数MovRedo(pData)与MovUndo(pData)类似就不多说了.
由3,4可以看出,在回退与重做过程中,只是保存和取出操作对象已变化的过程,使编程者很容易实现高效率刷新与充分节约存储空间.
小结
在系统编程中,文档的回退与重做几乎是必不可少的,本文提出了一种思路,即对文档的各种操作分解,并把每种操作下变化的对象的数据值保存于临时文件(栈)中,在回退与重做时根据变化量很容易恢复操作之前状态或重做, 避免了有些系统(保存全部文档数据)占用大量内存空间而只能有限次文档逆向化,并且全部刷新而闪烁,破坏了界面的友好性。
怎样在一个Pane中显示多种View？
在MS Windows 中，一个窗口可以分割成若干个子窗口，每一个子窗口称作一个窗片(pane)，每个窗片可以独立控制，这给界面设计提供了很大的方便。
---- 利用VC 可以很方便地实现分割窗口。分割的方法有两种：动态和静态。动态分割时可以根据用户的需要分割成数目不同的窗片，但所有窗片的属性和父窗口都是一样的；而静态分割的窗片的数目在程序中指定，运行时是固定的，但每个窗片可以有各自不同类型的视(View)，因此其使用范围更为广泛。本文所讨论的问题仅限于静态分割。
---- 窗片中视的类型大多是在主窗口的创建过程中指定的。这也就意味着，一个窗片虽然可以显示任意类型的视，但是这种类型一旦确定，在程序运行过程中就难以改变。
---- 一、我要的是这样的！
---- 但是我们有时确实需要改变一个窗片所显示的视的类型，也就是说，需要让一个窗片显示多种类型的视。例如一个窗口被分割成两部分，一边是命令窗口，另一边是工作窗口，根据命令窗口中发出的不同命令，需要变换不同的工作类型，这就需要工作窗口中能够显示多种类型的视窗，那么，如何做到这一点呢？
---- 二、你可以这样做！
---- 从图1 中可以看到，本程序共有三个视类，分别是：
---- ? 命令视类CCmdView：用来控制右边窗片中不同视的显示；
---- ? 选项按钮视类CRdiView：显示在右窗片中的选项视类；
---- ? 检查按钮视类CChkView：显示在右窗片中的检查视类。
---- 这三个视类都是CFormView 的子类。
---- 下面我们来看如何在右窗片内进行两类视间的切换。实际上，由视A 切换到视B 的原理很简单，那就是：
---- 1. 从窗片中删除视A；
---- 2. 往窗片中添加视B。
---- 步骤1 的实现非常简单，仅用一条语句即可：
---- m_wndSplitter.DeleteView(0, 1);
---- 但它是必不可少的，因为你不能让一个窗片同时包含两个视。我本来希望往一个窗片中添加新的视时，VC 会自动将原来的视删簦墒撬桓伞?br>
---- 我们来看如何实现步骤2，当一个窗片是空的时候，怎样往里面添加一个视呢？其实这样的功能在程序里我们已经用过了，看下面的语句：
BOOL CMainFrame::OnCreateClient
(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
……
if (!m_wndSplitter.CreateView(0, 0,
pContext->m_pNe ewClass,
size,
pContext))
……
}
---- 是的，用的就是CSplitterWnd::CreateView()，要注意的是它共有五个参数，其中前两个用来指定分割窗口的窗片，第三个用来指定视的类型，第四个指定视的大小。最后的一个我们暂时用不上，用空值NULL 就可以了。
---- 这样我们就可以编写视切换的代码了。因为视切换要操纵m_wndSplitter，而它是主窗口的成员，因此切换过程最好设计为主窗口的成员函数。但是切换命令是CCmdView 接受的，因而可以让CCmdView 接受到视更改消息后，将消息传给主窗口，由主窗口完成视更改。具体的代码是这样的：
---- 命令视类中的消息映射：
BEGIN_MESSAGE_MAP(CCmdView, CFormView)
……
ON_BN_CLICKED(IDC_CHECK, OnSwitchToCheckView)
ON_BN_CLICKED(IDC_RADIO, OnSwitchToRadioView)
……
END_MESSAGE_MAP()
命令视类中的消息响应：
void CCmdView::OnSwitchToCheckView()
{
AfxGetApp()->m_pMainWnd->
SendMessage(WM_COMMAND, ID_CHECK);
}
void CCmdView::OnSwitchToRadioView()
{
AfxGetApp()->m_pMainWnd->
SendMessage(WM_COMMAND, ID_RADIO);
}
主窗口中的消息映射：
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
……
ON_COMMAND(ID_CHECK, OnSwitchToCheckView)
ON_COMMAND(ID_RADIO, OnSwitchToRadioView)
……
END_MESSAGE_MAP()
主窗口中的消息响应：
void CMainFrame::OnSwitchToCheckView()
{
m_wndSplitter.DeleteView(0, 1);
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CChkView),
CSize(0, 0),
NULL);
m_wndSplitter.RecalcLayout();
}
void CMainFrame::OnSwitchToRadioView()
{
m_wndSplitter.DeleteView(0, 1);
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CRdiView),
CSize(0, 0),
NULL);
m_wndSplitter.RecalcLayout();
}
---- 好啦，运行一下这个程序，感觉是否不错？看来大功告成了，可是……
---- 三、还有一个问题
---- 在运行我们辛辛苦苦编出来的程序时，回头看看VC 的调试窗口，你会发现有很多行这样的话：
---- Create view without document.
---- 这是说我们创建了视，可是没有相应的文档。好在这只是警告信息，不是什么错误，如果你不需要相应的文档，就完全不用去管它。可是，VC 中一种很重要的结构就是文档- 视结构，利用这种结构，对数据操纵起来非常方便。如果需要建立与视相对应的文档，应该怎么办呢？
---- 这就涉及到VC 中文档- 视结构的知识，不过不用怕麻烦，与本文有关的就只有这么两点而已：
---- 1. 利用VC 创建的应用程序一般都会管理一些文档模板(Document Template)，文档类和视类的对应关系就是在文档模板里描述的。
---- 2. 一个文档可以有多个视，创建视的时候，需要根据文档和视的对应关系，给出它所依附的文档。
---- 怎样实现上述第一点呢？
---- 首先建立相应的文档类：CRdiDoc 和CChkDoc。
---- 其次是定义相应的文档模板，这是应用类的成员变量。因为在别的类中要使用它们，我们将之定义为公共类型：
class CViewSwitcherApp : public CWinApp
{
……
public:
CSingleDocTemplate* m_pRdiDocTemplate;
CSingleDocTemplate* m_pChkDocTemplate;
……
}
然后创建这两个文档模板，并加入到模板列表中：
BOOL CViewSwitcherApp::InitInstance()
{
……
m_pRdiDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CRdiDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CRdiView));
AddDocTemplate(m_pRdiDocTemplate);
m_pChkDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CChkDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CChkView));
AddDocTemplate(m_pChkDocTemplate);
……
}
---- 至于第二点，是在创建视时完成的。还记得创建视的情况么？当时有一个叫做pCreateContext 的参数，我们将之置为空，这里就要用到它了。
---- pCreateContext 是一个指向被称作" 创建上下文"(CreateContext) 结构的指针，这个结构中保存一些与创建视相关的内容。在创建主窗口时，系统会构造这样一个结构，并将它作为参数传递到与创建视有关的函数中。但现在我们不创建主窗口，因此不得不自己构造这样一个结构。实际上，该结构中我们所要使用的字段只有三个：
---- 1. 新视所属的文档模板m_pNewDocTemplate；
---- 2. 新视的类型m_pNewViewClass；
---- 3. 新视所属的文档m_pCurrentDoc；
---- 其中仅有第三项需要新建，前两项都是已知的，只要指定即可。以切换到选项视为例，修改后的代码是：
void CMainFrame::OnSwitchToRadioView()
{
m_wndSplitter.DeleteView(0, 1);
CCreateContext createContext;
// 定义并初始化CreateContext
// 获取新视所属的文档模板
CSingleDocTemplate* pDocTemplate =
((CViewSwitcherApp*)AfxGetApp())-> m_pRdiDocTemplate;
// 创建新文档并初始化
CDocument* pDoc = pDocTemplate->CreateNewDocument();
pDoc->OnNewDocument();
// 设置CreateContext 相关字段
createContext.m_pNewViewClass = RUNTIME_CLASS(CChkView);
createContext.m_pCurrentDoc = pDoc;
createContext.m_pNewDocTemplate = pDocTemplate;
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CRdiView),
CSize(0, 0),
&createContext);
m_wndSplitter.RecalcLayout();
}
---- 四、最后的修改
---- 为了使这个程序更符合要求，我们还要做一些与更换视无关的修改。在这个程序中我们一共定义了三种类型的文档，程序启动时一般要新建一个文档开始工作，可是它不知道要选择哪一种，就弹出一个对话框来询问。而这是我们不希望看到的。修改的方法是不让VC 选择新文档类型，而我们指定创建哪一种类型的文档，即把CViewSwitcherApp::CViewSwitcherApp() 中的语句
---- if (!ProcessShellCommand(cmdInfo)) return FALSE;
---- 更改为
---- m_pDocTemplate->OpenDocumentFile(NULL)。
让基于对话框应用程序也有启动画面
用MFC的应用向导创建一个有主框架结构的应用程序，要使它具有启动画面是很简单的（下面会体验到），而要使一个基于对话框的应用程序也有启动画面则要费些事了，不过按以下笔者的方法则也是很容易的，我主要介绍方法，对画面仅采用默认情况，读者有兴趣可自己加工。
一、给一文档/视图应用程序做启动画面
（一） 建立一单文档/视图应用程序Hs
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Hs作为项目名并单击OK。在第一步中选中Single Document单选按钮，其它接受所有默认选项。
（二） 添加启动画面
当AppWizard完成，而且Visual C++打开项目的时候，从Project菜单中选择Add To Project，并单击位于次级菜单上的Comonents and Controls…，选择Splash screen组件，如图1(略)所示，单击Insert。接受所有的默认设置。
以上几步就建立起了一个有主框架结构的应用程序，并使它具有了启动画面。这是我们要做的准备工作已经完成。
二、给基于对话框应用程序做启动画面
(一）建立基于对话框的应用程序Spla
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Spla 作为项目名并单击OK。在第一步中选中Dialog Based单选按钮，其它接受所有默认选项。
(二）做启动画面
这里做启动画面如果仍采用前述用Gallery来插入是不行的，因为基于对话框的应用程序没有主框架。不过我们可以把上面建立起的启动画面文件移植过来，然后，对程序进行少许编程修改就行。请按照下面的步骤来做:
1、将Splash.cpp和Splash.h两个文件从Hs工程中拷贝到你的工程中。添加如下代码到CSplaApp的InitInstance()函数中。
#include "Splash.h"//头文件请放在开始位置
BOOL CSplaApp::InitInstance()
{
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
CSplashWnd::EnableSplashScreen
(cmdInfo.m_bShowSplash);
...
}
2、接下来，使用ClassWizard来添加OnCreate函数到你的对话框类中，并且添加如下代码： #include "Splash.h"//头文件请放在开始位置
int CSplaDlg::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
CSplashWnd::ShowSplashScreen(this);
…
}
3、将Splash16.bmp文件从Hs工程中拷贝到你的工程中 蚩猈orkspace的Resouce项，将Splash16.bmp插入。打开Properties将IDB_BITMAP1改为IDB_SPLASH，这个ID值只要和程序中一致起来就行，现在这样改最简便。
现在可以编译运行程序了，程序运行时出现如图2(略)的启动画面。这是默认的画面，你可以打开图形编辑器自己加工。如果你要改变启动画面的停留时间，就修改SetTime中的第二个参数，这里是750毫秒。
int CSplashWnd::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
// Set a timer to destroy the splash screen.
SetTimer(1, 750, NULL);
return 0;
}
一、给一文档/视图应用程序做启动画面
（一） 建立一单文档/视图应用程序Hs
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Hs作为项目名并单击OK。在第一步中选中Single Document单选按钮，其它接受所有默认选项。
（二） 添加启动画面
当AppWizard完成，而且Visual C++打开项目的时候，从Project菜单中选择Add To Project，并单击位于次级菜单上的Comonents and Controls…，选择Splash screen组件，如图1(略)所示，单击Insert。接受所有的默认设置。
以上几步就建立起了一个有主框架结构的应用程序，并使它具有了启动画面。这是我们要做的准备工作已经完成。
二、给基于对话框应用程序做启动画面
(一）建立基于对话框的应用程序Spla
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Spla 作为项目名并单击OK。在第一步中选中Dialog Based单选按钮，其它接受所有默认选项。
(二）做启动画面
这里做启动画面如果仍采用前述用Gallery来插入是不行的，因为基于对话框的应用程序没有主框架。不过我们可以把上面建立起的启动画面文件移植过来，然后，对程序进行少许编程修改就行。请按照下面的步骤来做:
1、将Splash.cpp和Splash.h两个文件从Hs工程中拷贝到你的工程中。添加如下代码到CSplaApp的InitInstance()函数中。
#include "Splash.h"//头文件请放在开始位置
BOOL CSplaApp::InitInstance()
{
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
CSplashWnd::EnableSplashScreen
(cmdInfo.m_bShowSplash);
...
}
2、接下来，使用ClassWizard来添加OnCreate函数到你的对话框类中，并且添加如下代码： #include "Splash.h"//头文件请放在开始位置
int CSplaDlg::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
CSplashWnd::ShowSplashScreen(this);
…
}
3、将Splash16.bmp文件从Hs工程中拷贝到你的工程中 蚩猈orkspace的Resouce项，将Splash16.bmp插入。打开Properties将IDB_BITMAP1改为IDB_SPLASH，这个ID值只要和程序中一致起来就行，现在这样改最简便。
现在可以编译运行程序了，程序运行时出现如图2(略)的启动画面。这是默认的画面，你可以打开图形编辑器自己加工。如果你要改变启动画面的停留时间，就修改SetTime中的第二个参数，这里是750毫秒。
int CSplashWnd::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
// Set a timer to destroy the splash screen.
SetTimer(1, 750, NULL);
return 0;
}
俺有另一经验可实现之。
由于一般窗口大小的改变，都是用户拖动窗口边框而造成的。所以，我们可以截获主窗口消息WM_NCHITTEST在其响应函数中判断CWnd::OnNcHitTest()的返回值是否为HTRIGHT,HTLEFT,HTTOP,HTBOTTOM四个值之一，如果是，说明用户此时已点击了四个边框之一，此时我们应该返回HTCLIENT.那么，鼠标的形状就不会变成水平或垂直的双向箭头，用户就不可能依靠拖动边框来改变窗口大小了。
另外，还应补上一个小漏洞，就是还要把系统菜单中的SC_SIZE去掉。
主程序之前的版权窗口
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
DWORD lTime;
try
{
Application->Initialize();
AboutBox=new TAboutBox(AboutBox);
AboutBox->BorderStyle=bsNone;
AboutBox->OKButton->Visible=false;
AboutBox->Height=185;
AboutBox->Show();
AboutBox->Update();
lTime=GetTickCount();
Application->CreateForm(__classid(TMainForm), &MainForm);
while((GetTickCount()-lTime) / 1000 < 3);
AboutBox->Hide();
AboutBox->Free();
Application->Run();
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
return 0;
}
VISUAL C++6.0在MDI主框架窗口中添加位图
笔者在开发项目时想在MDI程序中添加彩色位图以美化界面，也实验了几种方法，但都有一些小问题，经多方查找资料，终于圆满的实现了这种功能，现把我的实现方法介绍给大家。
首先要清楚对于一个MDI应用程序的主框架窗口来说包含一个特殊的子窗口称为MDICLIENT窗口，应用程序的主框架类中有一个成员变量m_hWndMDIClient 指的就是MDICLIENT窗口。MDICLIENT窗口负责管理主框架窗口的客户区，对MDI客户窗口编程有一定的难度。原因是MDIFrameWnd的客户区完全被MDICLIENT窗口覆盖掉了。这样，MDI主窗口类MDIFrameWnd的背景色和光标都不起作用。同时，微软并不支持将MDICLIENT窗口作为子类，MDICLIENT窗口只能使用标准的背景色和光标。所以，对MDI客户窗口编程不能象对普通窗口那样简单地重载WM_PAINT的消息处理函数。我们可以在主框架窗口截获关于MDICLIENT窗口的重画消息，然后加入自己设计的代码。我用PreTranslateMessage(MSG* pMsg) 截获MDI客户窗口WM_PAINT消息，在这个函数中向主框架窗口发送WM_PAINT消息，在该消息的处理函数中实现彩色位图的显示。我的具体实现如下：1、向程序添加256色彩色位图资源，命名为IDB_BITMAP1；2、用ClassWizard向主框架类添加函数CMainFrame::PreTranslateMessage(MSG* pMsg)；3、用ClassWizard向主框架类添加函数CMainFrame::OnPaint()；现给出两个函数的实现：
BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
// TODO: Add your specialized code here and/or call the base class
if(pMsg->hwnd==m_hWndMDIClient && pMsg->message==WM_PAINT)
PostMessage(WM_PAINT);
return CMDIFrameWnd::PreTranslateMessage(pMsg);
}
void CMainFrame::OnPaint()
{
CDC dc, memdc;
dc.m_hDC=::GetDC(this->m_hWndMDIClient);
CRect rect;
CBitmap bitmap;
BITMAP szbitmap;
bitmap.LoadBitmap(IDB_BITMAP1);
bitmap.GetObject(sizeof(BITMAP),&szbitmap);
CSize size(szbitmap.bmWidth,szbitmap.bmHeight);
memdc.CreateCompatibleDC(&dc);
CBitmap *oldbitmap=memdc.SelectObject(&bitmap);
GetClientRect(&rect);
StretchBlt(dc.m_hDC,0,0,rect.Width(),rect.Height(),
memdc.m_hDC,0,0,size.cx,size.cy,SRCCOPY);
memdc.SelectObject(oldbitmap);
memdc.DeleteDC();
dc.DeleteDC();
CMDIFrameWnd::OnPaint();
}
按上述步骤就可以实现在MDI程序中显示彩色位图了，我举的例子用的是256色位图，你也可以实现真彩色位图的显示，具体方法我就不多说了，有兴趣的朋友可以试一试。
华丽的界面
VC6.0实现逆向操作并防止界面闪烁
在系统编程中，使用VC是很好的开发工具，而对于一个成熟的系统，几乎都需要有回退与重做功能（即文档操作逆向化）以防止用户误操作或不合适的操作，从而提高系统的友好性和可操作性。在很多VC技术文章中均提到过这个问题，不过总存在着界面闪烁或不完全可逆．
本文提出一种对系统编程可实现完全可逆并防止闪屏的方法．
一、基本原理
要对文档进行回退重做功能，要做两方面的工作，一方面要保留删除的文档（在操作过程中，删除的文档资料一定能够保留），另一方面，系统必须能够记录进行文档操作的全过程及每个操作过程的参数。为了保留历史操作，所有数据非常占用内存空间，这就是一些系统只能进行有限次退步逆向操作的原因。本文提出的方法建立如下存储机制：建一个临时文件储存数据模拟堆栈，进行一次操作时将相关操作数据入栈．回退一次将相关数据弹出栈，重做一次又依据相关数据重新恢复原有数据．它的好处是在回退和重做时只入一次栈即申请一次内存。
堆栈的数据排放如图：
// Undo、Redo 数据排放示意图（m_UndoDataList）
//
// ====
// |###| }
// |###| }
// |###| } ----->> Redo 数据
// |###| }
// |###| }
// |\\\| }
// |\\\| }
// |\\\| }
// |\\\| } --->> Undo 数据（Undo数据弹出后将转换为Redo数据）
// |\\\| }
// |\\\| }
// =====
// Undo数据栈
二、实现文档回退重做的引擎
建一文档逆向化堆栈引擎．主要代码为：
1.建立临时文件．（m_TempPath可以按照某种规则形成路径）
if(m_File.Open((LPCTSTR)m_TempPath, CFile::modeCreate|CFile::modeReadWrite|CFile::shareExclusive))
{
m_File.SeekToBegin();
m_UndoCount = 0; file://当前可重做的步数
m_RedoCount = 0; file://当前可回退的步数
｝
2．保存回退数据模块．
// 保存一个Undo数据块（由用户提供）
int CRedoUndoEngine::PushData(
LPVOID pData,
// 由用户提供的内存块首地址，其中含有用户定义的待保存的数据。
// （注：如果函数成功，此内存块将会被本函数释放，因此，该内存块必须是用::GlobalAlloc()函数分配的）
DWORD size, // pData指向的内存块尺寸
DWORD param1,
// 用户提供的对该内存块的说明参数，含义由用户定义
DWORD param2,
// 用户提供的对该内存块的说明参数，含义由用户定义
int *pIndex
// 如果成功，本函数将返回压入的Undo块在栈中的索引值。
如果不需要此返回值，可用NULL作为参数
)
{
// 删除Redo数据
if (m_RedoCount)
{
while(m_RedoCount--)
delete (LPISEEUNDOINFO)m_UndoDataList.RemoveTail();
m_RedoCount = 0;
}
// 填写Undo数据的索引信息(lpISeeUndoInfo为一个保存数据的结构体)
lpISeeUndoInfo->m_index = m_UndoCount; // 索引
lpISeeUndoInfo->m_UserData1 = param1;
// 用户定义的标识性数据1
lpISeeUndoInfo->m_UserData2 = param2;
// 用户定义的标识性数据2
lpISeeUndoInfo->m_DataSize = size; // 用户的Undo数据块尺寸
lpISeeUndoInfo->m_FilePosition =
_get_current_overwrite_pos();
// 加新的Undo数据到Undo栈的尾部
m_UndoDataList.AddTail((void*)lpISeeUndoInfo);
// 将用户的Undo数据写入临时文件
m_File.Seek(lpISeeUndoInfo->m_FilePosition, CFile::begin);
m_File.Write((const void *)pData, size);
并使Undo块计数加1
m_UndoCount++;
// 此时用户传过来的数据块已经无用，删除！
::GlobalFree(pData);
return 1;
}
3.弹出重做数据模块．
// 弹出一个Redo数据块
int CIUndoEngine::RedoData(
LPVOID *ppData, // 用于接收本函数返回的含有最近一个Redo数据的内存块首地址的指针
// （注：此内存块交由调用者释放，使用::GlobalFree()函数）
DWORD *pSize, // ppData内存块的尺寸(in byte) ，如果不需要此数据可用NULL作为参数
DWORD *pParam1, // 返回用户对该Redo块的附加信息，如果不需要此数据可用NULL作为参数
DWORD *pParam2, // 返回用户对该Redo块的附加信息，如果不需要此数据可用NULL作为参数
int *pIndex // 返回本Redo块的索引，如果不需要此数据可用NULL作为参数
)
{
if (!m_RedoCount)
return 0;
// 锁定待弹出的Redo索引信息块的地址
POSITION pos = m_UndoDataList.FindIndex(m_UndoCount);
ASSERT(pos);
LPISEEUNDOINFO lpISeeUndoInfo= (LPISEEUNDOINFO)m_UndoDataList.GetAt(pos);
ASSERT(lpISeeUndoInfo);
ASSERT(lpISeeUndoInfo->m_index == m_UndoCount);
if (!(*ppData))
return -1;
// 读出用户保存在临时文件中的Undo数据（也即Redo数据）
m_File.Seek((LONG)lpISeeUndoInfo->m_FilePosition, CFile::begin);
m_File.Read(*ppData, lpISeeUndoInfo->m_DataSize);
m_UndoCount++; // 可用Undo数据块个数加1
m_RedoCount--; // 可用Redo数据块个数减1
if (pSize)
*pSize = lpISeeUndoInfo->m_DataSize;
if (pParam1)
*pParam1= lpISeeUndoInfo->m_UserData1;
if (pParam2)
*pParam2= lpISeeUndoInfo->m_UserData2;
if (pIndex)
*pIndex = m_RedoCount;// 注：此处的索引是Redo的索引，而不是Undo的
return 1;
}
由这个文档逆向化操作引擎，可以获得当前改动的文档的数据，并根据改动的数据更新视图，而不刷新没有更改数据的视图.从而防止了闪烁的产生．
三、简单开发实例
下面以我们开发服装CAD过程中加入的回退重做功能（文档逆向化）说明之。
1.定义回退类型
#define REUNDO_MOV 0x0001 file://衣片移动回退重做
#define REUNDO_SEL 0x0002 file://衣片选择回退重做
……….
2.保存某个操作之前和之后的数据(以衣片移动回退重做为例)
//----------申请内存----------------------//
int nByte = 4*sizeof(DWORD);
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);
LPVOID pData = (LPVOID) GlobalLock(hMem);
file://-----保存衣片移动前后的位置读入内存------//用移动前后衣片的某个坐标点表示
memcpy((DWORD*)pData, &m_oldPoint, 2*sizeof(DWORD));
memcpy((DWORD*)pData+2,&point, 2*sizeof(DWORD));
file://--------数据入栈---------------------------------------//
m_pReUndoEngine->PushData(pData,//衣片m_pReUndoEngine文档逆向化引擎对象指针
nByte,//保存数据衣片字节数
REUNDO_MOV,//回退类型
NULL,NULL);
3.当回退操作事件触发时.
//弹出回退值
int nByte = m_pReUndoEngine->GetPopDataSize();
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);//申请内存
LPVOID pData = (LPVOID) GlobalLock(hMem);
DWORD undo_type;DWORD index;
m_pReUndoEngine->PopData(&pData,NULL,&undo_type,&index);
////////////////////////////////
switch(undo_type){//回退类型
case REUNDO_SEL:
SelUndo(pData,index,&dc);break;
case REUNDO_MOV:
MovUndo(pData);break;
…………
}
void CMarkView::MovUndo(LPVOID pData) 函数功能
{
CPoint pt1,pt2;
memcpy(&pt1,(DWORD*)pData,8);
memcpy(&pt2,(DWORD*)pData+2,8);
…….由pt1 和pt2可以求出位移量,从而恢复原衣片的位置.
}
4.当重做操作事件触发时
//弹出回退值
int nByte = m_pReUndoEngine->GetRedoDataSize();
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED,nByte);//申请内存
LPVOID pData = (LPVOID) GlobalLock(hMem);
DWORD undo_type;DWORD index;
m_pReUndoEngine->RedoData(&pData,NULL,&undo_type,&index);
switch(undo_type){//回退类型
case REUNDO_SEL:
SelRedo(pData,index,&dc,nByte);break;
case REUNDO_MOV:
MovRedo(pData); break;
…………
}
函数MovRedo(pData)与MovUndo(pData)类似就不多说了.
由3,4可以看出,在回退与重做过程中,只是保存和取出操作对象已变化的过程,使编程者很容易实现高效率刷新与充分节约存储空间.
小结
在系统编程中,文档的回退与重做几乎是必不可少的,本文提出了一种思路,即对文档的各种操作分解,并把每种操作下变化的对象的数据值保存于临时文件(栈)中,在回退与重做时根据变化量很容易恢复操作之前状态或重做, 避免了有些系统(保存全部文档数据)占用大量内存空间而只能有限次文档逆向化,并且全部刷新而闪烁,破坏了界面的友好性。
怎样在一个Pane中显示多种View？
在MS Windows 中，一个窗口可以分割成若干个子窗口，每一个子窗口称作一个窗片(pane)，每个窗片可以独立控制，这给界面设计提供了很大的方便。
---- 利用VC 可以很方便地实现分割窗口。分割的方法有两种：动态和静态。动态分割时可以根据用户的需要分割成数目不同的窗片，但所有窗片的属性和父窗口都是一样的；而静态分割的窗片的数目在程序中指定，运行时是固定的，但每个窗片可以有各自不同类型的视(View)，因此其使用范围更为广泛。本文所讨论的问题仅限于静态分割。
---- 窗片中视的类型大多是在主窗口的创建过程中指定的。这也就意味着，一个窗片虽然可以显示任意类型的视，但是这种类型一旦确定，在程序运行过程中就难以改变。
---- 一、我要的是这样的！
---- 但是我们有时确实需要改变一个窗片所显示的视的类型，也就是说，需要让一个窗片显示多种类型的视。例如一个窗口被分割成两部分，一边是命令窗口，另一边是工作窗口，根据命令窗口中发出的不同命令，需要变换不同的工作类型，这就需要工作窗口中能够显示多种类型的视窗，那么，如何做到这一点呢？
---- 二、你可以这样做！
---- 从图1 中可以看到，本程序共有三个视类，分别是：
---- ? 命令视类CCmdView：用来控制右边窗片中不同视的显示；
---- ? 选项按钮视类CRdiView：显示在右窗片中的选项视类；
---- ? 检查按钮视类CChkView：显示在右窗片中的检查视类。
---- 这三个视类都是CFormView 的子类。
---- 下面我们来看如何在右窗片内进行两类视间的切换。实际上，由视A 切换到视B 的原理很简单，那就是：
---- 1. 从窗片中删除视A；
---- 2. 往窗片中添加视B。
---- 步骤1 的实现非常简单，仅用一条语句即可：
---- m_wndSplitter.DeleteView(0, 1);
---- 但它是必不可少的，因为你不能让一个窗片同时包含两个视。我本来希望往一个窗片中添加新的视时，VC 会自动将原来的视删簦墒撬桓伞?br>
---- 我们来看如何实现步骤2，当一个窗片是空的时候，怎样往里面添加一个视呢？其实这样的功能在程序里我们已经用过了，看下面的语句：
BOOL CMainFrame::OnCreateClient
(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
……
if (!m_wndSplitter.CreateView(0, 0,
pContext->m_pNe ewClass,
size,
pContext))
……
}
---- 是的，用的就是CSplitterWnd::CreateView()，要注意的是它共有五个参数，其中前两个用来指定分割窗口的窗片，第三个用来指定视的类型，第四个指定视的大小。最后的一个我们暂时用不上，用空值NULL 就可以了。
---- 这样我们就可以编写视切换的代码了。因为视切换要操纵m_wndSplitter，而它是主窗口的成员，因此切换过程最好设计为主窗口的成员函数。但是切换命令是CCmdView 接受的，因而可以让CCmdView 接受到视更改消息后，将消息传给主窗口，由主窗口完成视更改。具体的代码是这样的：
---- 命令视类中的消息映射：
BEGIN_MESSAGE_MAP(CCmdView, CFormView)
……
ON_BN_CLICKED(IDC_CHECK, OnSwitchToCheckView)
ON_BN_CLICKED(IDC_RADIO, OnSwitchToRadioView)
……
END_MESSAGE_MAP()
命令视类中的消息响应：
void CCmdView::OnSwitchToCheckView()
{
AfxGetApp()->m_pMainWnd->
SendMessage(WM_COMMAND, ID_CHECK);
}
void CCmdView::OnSwitchToRadioView()
{
AfxGetApp()->m_pMainWnd->
SendMessage(WM_COMMAND, ID_RADIO);
}
主窗口中的消息映射：
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
……
ON_COMMAND(ID_CHECK, OnSwitchToCheckView)
ON_COMMAND(ID_RADIO, OnSwitchToRadioView)
……
END_MESSAGE_MAP()
主窗口中的消息响应：
void CMainFrame::OnSwitchToCheckView()
{
m_wndSplitter.DeleteView(0, 1);
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CChkView),
CSize(0, 0),
NULL);
m_wndSplitter.RecalcLayout();
}
void CMainFrame::OnSwitchToRadioView()
{
m_wndSplitter.DeleteView(0, 1);
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CRdiView),
CSize(0, 0),
NULL);
m_wndSplitter.RecalcLayout();
}
---- 好啦，运行一下这个程序，感觉是否不错？看来大功告成了，可是……
---- 三、还有一个问题
---- 在运行我们辛辛苦苦编出来的程序时，回头看看VC 的调试窗口，你会发现有很多行这样的话：
---- Create view without document.
---- 这是说我们创建了视，可是没有相应的文档。好在这只是警告信息，不是什么错误，如果你不需要相应的文档，就完全不用去管它。可是，VC 中一种很重要的结构就是文档- 视结构，利用这种结构，对数据操纵起来非常方便。如果需要建立与视相对应的文档，应该怎么办呢？
---- 这就涉及到VC 中文档- 视结构的知识，不过不用怕麻烦，与本文有关的就只有这么两点而已：
---- 1. 利用VC 创建的应用程序一般都会管理一些文档模板(Document Template)，文档类和视类的对应关系就是在文档模板里描述的。
---- 2. 一个文档可以有多个视，创建视的时候，需要根据文档和视的对应关系，给出它所依附的文档。
---- 怎样实现上述第一点呢？
---- 首先建立相应的文档类：CRdiDoc 和CChkDoc。
---- 其次是定义相应的文档模板，这是应用类的成员变量。因为在别的类中要使用它们，我们将之定义为公共类型：
class CViewSwitcherApp : public CWinApp
{
……
public:
CSingleDocTemplate* m_pRdiDocTemplate;
CSingleDocTemplate* m_pChkDocTemplate;
……
}
然后创建这两个文档模板，并加入到模板列表中：
BOOL CViewSwitcherApp::InitInstance()
{
……
m_pRdiDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CRdiDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CRdiView));
AddDocTemplate(m_pRdiDocTemplate);
m_pChkDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CChkDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CChkView));
AddDocTemplate(m_pChkDocTemplate);
……
}
---- 至于第二点，是在创建视时完成的。还记得创建视的情况么？当时有一个叫做pCreateContext 的参数，我们将之置为空，这里就要用到它了。
---- pCreateContext 是一个指向被称作" 创建上下文"(CreateContext) 结构的指针，这个结构中保存一些与创建视相关的内容。在创建主窗口时，系统会构造这样一个结构，并将它作为参数传递到与创建视有关的函数中。但现在我们不创建主窗口，因此不得不自己构造这样一个结构。实际上，该结构中我们所要使用的字段只有三个：
---- 1. 新视所属的文档模板m_pNewDocTemplate；
---- 2. 新视的类型m_pNewViewClass；
---- 3. 新视所属的文档m_pCurrentDoc；
---- 其中仅有第三项需要新建，前两项都是已知的，只要指定即可。以切换到选项视为例，修改后的代码是：
void CMainFrame::OnSwitchToRadioView()
{
m_wndSplitter.DeleteView(0, 1);
CCreateContext createContext;
// 定义并初始化CreateContext
// 获取新视所属的文档模板
CSingleDocTemplate* pDocTemplate =
((CViewSwitcherApp*)AfxGetApp())-> m_pRdiDocTemplate;
// 创建新文档并初始化
CDocument* pDoc = pDocTemplate->CreateNewDocument();
pDoc->OnNewDocument();
// 设置CreateContext 相关字段
createContext.m_pNewViewClass = RUNTIME_CLASS(CChkView);
createContext.m_pCurrentDoc = pDoc;
createContext.m_pNewDocTemplate = pDocTemplate;
m_wndSplitter.CreateView(0, 1,
RUNTIME_CLASS(CRdiView),
CSize(0, 0),
&createContext);
m_wndSplitter.RecalcLayout();
}
---- 四、最后的修改
---- 为了使这个程序更符合要求，我们还要做一些与更换视无关的修改。在这个程序中我们一共定义了三种类型的文档，程序启动时一般要新建一个文档开始工作，可是它不知道要选择哪一种，就弹出一个对话框来询问。而这是我们不希望看到的。修改的方法是不让VC 选择新文档类型，而我们指定创建哪一种类型的文档，即把CViewSwitcherApp::CViewSwitcherApp() 中的语句
---- if (!ProcessShellCommand(cmdInfo)) return FALSE;
---- 更改为
---- m_pDocTemplate->OpenDocumentFile(NULL)。
让基于对话框应用程序也有启动画面
用MFC的应用向导创建一个有主框架结构的应用程序，要使它具有启动画面是很简单的（下面会体验到），而要使一个基于对话框的应用程序也有启动画面则要费些事了，不过按以下笔者的方法则也是很容易的，我主要介绍方法，对画面仅采用默认情况，读者有兴趣可自己加工。
一、给一文档/视图应用程序做启动画面
（一） 建立一单文档/视图应用程序Hs
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Hs作为项目名并单击OK。在第一步中选中Single Document单选按钮，其它接受所有默认选项。
（二） 添加启动画面
当AppWizard完成，而且Visual C++打开项目的时候，从Project菜单中选择Add To Project，并单击位于次级菜单上的Comonents and Controls…，选择Splash screen组件，如图1(略)所示，单击Insert。接受所有的默认设置。
以上几步就建立起了一个有主框架结构的应用程序，并使它具有了启动画面。这是我们要做的准备工作已经完成。
二、给基于对话框应用程序做启动画面
(一）建立基于对话框的应用程序Spla
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Spla 作为项目名并单击OK。在第一步中选中Dialog Based单选按钮，其它接受所有默认选项。
(二）做启动画面
这里做启动画面如果仍采用前述用Gallery来插入是不行的，因为基于对话框的应用程序没有主框架。不过我们可以把上面建立起的启动画面文件移植过来，然后，对程序进行少许编程修改就行。请按照下面的步骤来做:
1、将Splash.cpp和Splash.h两个文件从Hs工程中拷贝到你的工程中。添加如下代码到CSplaApp的InitInstance()函数中。
#include "Splash.h"//头文件请放在开始位置
BOOL CSplaApp::InitInstance()
{
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
CSplashWnd::EnableSplashScreen
(cmdInfo.m_bShowSplash);
...
}
2、接下来，使用ClassWizard来添加OnCreate函数到你的对话框类中，并且添加如下代码： #include "Splash.h"//头文件请放在开始位置
int CSplaDlg::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
CSplashWnd::ShowSplashScreen(this);
…
}
3、将Splash16.bmp文件从Hs工程中拷贝到你的工程中 蚩猈orkspace的Resouce项，将Splash16.bmp插入。打开Properties将IDB_BITMAP1改为IDB_SPLASH，这个ID值只要和程序中一致起来就行，现在这样改最简便。
现在可以编译运行程序了，程序运行时出现如图2(略)的启动画面。这是默认的画面，你可以打开图形编辑器自己加工。如果你要改变启动画面的停留时间，就修改SetTime中的第二个参数，这里是750毫秒。
int CSplashWnd::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
// Set a timer to destroy the splash screen.
SetTimer(1, 750, NULL);
return 0;
}
一、给一文档/视图应用程序做启动画面
（一） 建立一单文档/视图应用程序Hs
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Hs作为项目名并单击OK。在第一步中选中Single Document单选按钮，其它接受所有默认选项。
（二） 添加启动画面
当AppWizard完成，而且Visual C++打开项目的时候，从Project菜单中选择Add To Project，并单击位于次级菜单上的Comonents and Controls…，选择Splash screen组件，如图1(略)所示，单击Insert。接受所有的默认设置。
以上几步就建立起了一个有主框架结构的应用程序，并使它具有了启动画面。这是我们要做的准备工作已经完成。
二、给基于对话框应用程序做启动画面
(一）建立基于对话框的应用程序Spla
从File菜单选择New对话，在Projects选项卡中选择AppWizard（exe）图标。键入Spla 作为项目名并单击OK。在第一步中选中Dialog Based单选按钮，其它接受所有默认选项。
(二）做启动画面
这里做启动画面如果仍采用前述用Gallery来插入是不行的，因为基于对话框的应用程序没有主框架。不过我们可以把上面建立起的启动画面文件移植过来，然后，对程序进行少许编程修改就行。请按照下面的步骤来做:
1、将Splash.cpp和Splash.h两个文件从Hs工程中拷贝到你的工程中。添加如下代码到CSplaApp的InitInstance()函数中。
#include "Splash.h"//头文件请放在开始位置
BOOL CSplaApp::InitInstance()
{
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
CSplashWnd::EnableSplashScreen
(cmdInfo.m_bShowSplash);
...
}
2、接下来，使用ClassWizard来添加OnCreate函数到你的对话框类中，并且添加如下代码： #include "Splash.h"//头文件请放在开始位置
int CSplaDlg::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
CSplashWnd::ShowSplashScreen(this);
…
}
3、将Splash16.bmp文件从Hs工程中拷贝到你的工程中 蚩猈orkspace的Resouce项，将Splash16.bmp插入。打开Properties将IDB_BITMAP1改为IDB_SPLASH，这个ID值只要和程序中一致起来就行，现在这样改最简便。
现在可以编译运行程序了，程序运行时出现如图2(略)的启动画面。这是默认的画面，你可以打开图形编辑器自己加工。如果你要改变启动画面的停留时间，就修改SetTime中的第二个参数，这里是750毫秒。
int CSplashWnd::OnCreate
(LPCREATESTRUCT lpCreateStruct)
{
…
// Set a timer to destroy the splash screen.
SetTimer(1, 750, NULL);
return 0;
}