MFC教程（13）-- MFC工具条和状态栏（2）

消息WM_POPMESSAGESTRING用来重新设置状态栏。

　　这两个消息对应的消息处理函数分别是OnSetMessageString和OnPopMessageString，OnSetMessageString和OnPopMessageString分别实现如下：

OnSetMessageString
LRESULT CFrameWnd::OnSetMessageString(WPARAM wParam, LPARAM lParam)
{
//最近一次被显示的消息字符串IDS（一个消息对应的字符串）
UINT nIDLast = m_nIDLastMessage;
m_nFlags &= ~WF_NOPOPMSG;
//得到状态栏
CWnd* pMessageBar = GetMessageBar();
if (pMessageBar != NULL)
{
LPCTSTR lpsz = NULL;
CString strMessage;
//设置状态栏文本
if (lParam != 0) //指向一个字符串
{
ASSERT(wParam == 0); // can't have both an ID and a string
lpsz = (LPCTSTR)lParam; // set an explicit string
}
else if (wParam != 0)//一个字符串资源IDS
{
//打印预览时映射SC_CLOSE成AFX_IDS_PREVIEW_CLOSE;
if (wParam == AFX_IDS_SCCLOSE && m_lpfnCloseProc != NULL)
wParam = AFX_IDS_PREVIEW_CLOSE;
//得到资源ID所标识的字符串
GetMessageString(wParam, strMessage);
lpsz = strMessage;
}
//在状态栏中显示文本
pMessageBar->SetWindowText(lpsz);
// 根据最近一次选择的消息更新状态条所属窗口的有关记录
CFrameWnd* pFrameWnd = pMessageBar->GetParentFrame();
if (pFrameWnd != NULL)
{
//记录最近一次显示的消息字符串
pFrameWnd->m_nIDLastMessage = (UINT)wParam;
//记录最近一次Tracking的命令ID和字符串IDS
pFrameWnd->m_nIDTracking = (UINT)wParam;
}
}
m_nIDLastMessage = (UINT)wParam; // new ID (or 0)
m_nIDTracking = (UINT)wParam; // so F1 on toolbar buttons work
return nIDLast;
}

　　OnSetMessageString函数直接或者从ID从字符串资源中得到字符串指针。如果是从ID得到字符串指针，则函数GetMessageString被调用。

　　和命令ID对应的字符串由两部分组成，前一部分用于在状态栏显示，后一部分用于Tooltip显示，分隔符号是“ ”。例如，字符串ID_APP_EXIT（对应“退出”菜单、按钮）是“Exit Application Exit”，当鼠标落在“退出”按钮上时，状态栏显示“Exit Application”，Tooltip显示“Exit”。根据这种格式，GetMessageString分离出第一部分的文本信息。至于第二部分的用途将在讨论Tooltip的章节将用到。

 

　　得到了字符串之后，OnSetMessageString调用状态栏的SetWindowText函数。SetWindowText导致消息WM_SETTEXT消息发送给状态栏，状态栏的消息处理函数OnSetText被调用，实际上等于调用了SetPaneText(0, lpsz)，即在状态栏的第0格中显示字符串lpsz的信息。对于工具栏来说，SetWindowText可以认为是SetPaneText(0, lpsz)的简化版本。

　　顺便指出，pMessageBar->GetParentFrame()返回主边框窗口，即使pMessageBar指向漂浮的工具条。关于泊位和漂浮，见后面13.2.5节的描述。

　　关于OnSetText，其实现如下：

LRESULT CStatusBar::OnSetText(WPARAM, LPARAM lParam)
{
ASSERT_VALID(this);
ASSERT(::IsWindow(m_hWnd));
int nIndex = CommandToIndex(0); //返回0
if (nIndex < 0)
return -1;
return SetPaneText(nIndex, (LPCTSTR)lParam) ? 0 : -1;
}
OnPopMessageString
LRESULT CFrameWnd::OnPopMessageString(WPARAM wParam,
LPARAM lParam)
{
//WF_NOPOPMSG表示边框窗口不处理WM_POPMESSAGESTRING
if (m_nFlags & WF_NOPOPMSG)
return 0;
//调用OnSetMessageString
return SendMessage(WM_SETMESSAGESTRING, wParam, lParam);
}

　　一般，在清除状态栏消息时，发送WM_POPMESSAGESTRING，通过消息参数wParam指定一个字符串资源，其ID 为AFX_IDS_IDLEMESSAGE，对应的字符串是“Ready”。

　　状态栏显示菜单项的提示信息

　　状态栏的一个重要作用是显示菜单命令或者工具条按钮的提示信息。本节讨论如何显示菜单命令的提示信息，关于工具条按钮在这方面的讨论见后面13.2.4.4章节。

　　显示菜单命令的提示信息，就是每当一个菜单项被选中之后，在状态栏显示该菜单的功能、用法等信息。这些信息以字符串资源的形式保存，字符串ID对应于菜单项的命令ID。

　　所以，必须处理菜单选择消息WM_MENUSELECT。CFrameWnd实现了消息处理函数OnMenuSelect，其实现如下：

void CFrameWnd::OnMenuSelect(UINT nItemID,
UINT nFlags, HMENU /*hSysMenu*/)
{
CFrameWnd* pFrameWnd = GetTopLevelFrame();
ASSERT_VALID(pFrameWnd);
//跟踪被选中的菜单项
if (nFlags == 0xFFFF)
{
//取消菜单操作
m_nFlags &= ~WF_NOPOPMSG;
if (!pFrameWnd->m_bHelpMode)
m_nIDTracking = AFX_IDS_IDLEMESSAGE;
else
m_nIDTracking = AFX_IDS_HELPMODEMESSAGE;
//在状态栏显示
SendMessage(WM_SETMESSAGESTRING, (WPARAM)m_nIDTracking);
ASSERT(m_nIDTracking == m_nIDLastMessage);
// update right away
CWnd* pWnd = GetMessageBar();
if (pWnd != NULL)
pWnd->UpdateWindow();
}
else
{
//选中分隔栏、Popup子菜单或者没有选中一个菜单项
if (nItemID == 0 || nFlags & (MF_SEPARATOR|MF_POPUP))
{
// nothing should be displayed
m_nIDTracking = 0;
}
else if (nItemID >= 0xF000 && nItemID < 0xF1F0) // max of 31 SC_s
{
//系统菜单的菜单项被选中
m_nIDTracking = ID_COMMAND_FROM_SC(nItemID);
ASSERT(m_nIDTracking >= AFX_IDS_SCFIRST &&
m_nIDTracking < AFX_IDS_SCFIRST + 31);
}
else if (nItemID >= AFX_IDM_FIRST_MDICHILD)
{
//如果选中的菜单项表示一个MDI子窗口
m_nIDTracking = AFX_IDS_MDICHILD;
}
else
{
//选中了一个菜单项
m_nIDTracking = nItemID;
}
pFrameWnd->m_nFlags |= WF_NOPOPMSG;
}
// when running in-place, it is necessary to cause a message to
// be pumped through the queue.
if (m_nIDTracking != m_nIDLastMessage && GetParent() != NULL)
PostMessage(WM_KICKIDLE);
}

　　OnMenuSelect的作用在于跟踪当前选中的菜单项，把菜单项对应的ID保存在CFrameWnd的成员变量m_nIDTracking中。

如果菜单项没有选中，或者选中的是一个子菜单，则设置nIDTracking为0。

　　如果选中的是系统菜单，则把系统菜单ID转换成一个对应的命令ID；保存该值到nIDTracking中。

　　如果选中的菜单是MDI子窗口创建时添加的（用来表示MDI子窗口），则转换菜单ID为AFX_IDS_MDICHILD，所有对应MDI子窗口的菜单项都使用AFX_IDS_MDICHILD，保存该值到nIDTracking中。

　　其他情况，就是选中菜单项的ID，把它保存到nIDTracking中。

　　跟踪被选择的菜单项并保存其ID在m_nIDTracking中，OnEnterIdle将用到m_nIDTracking。OnEnterIlde是消息WM_ENTERIDLE的处理函数，CFrameWnd的实现如下。

void CFrameWnd::OnEnterIdle(UINT nWhy, CWnd* pWho)
{
CWnd::OnEnterIdle(nWhy, pWho);
//若不是因为菜单选择进入该函数
//或者当前跟踪到的菜单项ID是最近一次处理的，则返回
if (nWhy != MSGF_MENU || m_nIDTracking == m_nIDLastMessage)
return;
//将发送消息WM_SETMESSAGETEXT
//在状态栏显示m_nIDTracking对应的字符串
SetMessageText(m_nIDTracking);
ASSERT(m_nIDTracking == m_nIDLastMessage);
}

　　当一个对话框或者菜单被显示的时候，Windows发送WM_ENTERIDLE消息。消息参数wParam取值为MSGF_DIALOGBOX或者MSGF_MENU。前者表示显示对话框时发送该消息，这时消息参数lParam表示对话框的句柄；后者表示显示菜单时发送该消息，这时消息参数lParam表示菜单的句柄。

　　经过消息映射，wParam的值传递给OnEnterIdle的参数nWhy，参数lParam的值传给参数who。如果参数1取值为MSGF_MENU，并且OnEnterIdle最近一次在菜单显示被调用时的菜单ID不同于这一次，则调用SetMessageText在状态栏显示对应ID命令的字符串，并且记录当前菜单ID到变量m_nIDTracking中（见消息处理函数OnSetMessageText）。

　　这样，在菜单选择期间，用户选择的菜单项ID被OnMenuSelect记录，在消息WM_ENTERIDLE处理时在状态栏显示ID命令的提示。

　　控制条的消息分发处理

　　工具条（包括对话框工具条）是一个子窗口，它们可以响应各种消息。如果按标准的Windows消息和命令消息的分发途径，一些消息不能送到拥有工具条的边框窗口，因为这些消息都将被工具条（对话框工具条）处理掉。所以，CControlBar覆盖了虚拟函数PreTranslateMessage和WindowProc以便实现特定的消息分发路径。

　　WindowProc

CControlBar 的WindowProc实现了如下的消息分发路径：

　　用户对控制条的输入消息或者分发给CControlBar及其派生类处理，或者送给拥有控制条的边框窗口处理，或者送给Windows控制“窗口类”的窗口过程处理。

　　WindowProc的实现如下：

LRESULT CControlBar::WindowProc(UINT nMsg,
WPARAM wParam, LPARAM lParam)
{
ASSERT_VALID(this);
LRESULT lResult;
switch (nMsg)
{
//本函数处理以下消息
case WM_NOTIFY:
case WM_COMMAND:
case WM_DRAWITEM:
case WM_MEASUREITEM:
case WM_DELETEITEM:
case WM_COMPAREITEM:
case WM_VKEYTOITEM:
case WM_CHARTOITEM:
//首先，工具条处理上述消息，如果没有处理，则接着给所属边框窗口处理
if (OnWndMsg(nMsg, wParam, lParam, &lResult))
return lResult;
else
return GetOwner()->SendMessage(nMsg, wParam, lParam);
}
}
// 最后，给基类CWnd，按缺省方式处理
lResult = CWnd::WindowProc(nMsg, wParam, lParam);
return lResult;
}

　　从上述实现可以看出，对于case范围内的一些消息，如WM_COMMAND、WM_NOTIFY等，控制条如果不能处理，则优先分发给其父窗口（边框窗口）处理，然后进入缺省处理，对于其他消息直接调用基类CWnd的实现（缺省处理）。基于这样的机制，可以把用户对工具条按钮或者对话框工具条内控制的操作解释成相应的命令消息，执行对应的命令处理。

　　对于工具条，当用户选中某个按钮时（鼠标左键弹起，消息是WM_LBUTTONUP），工具条窗口接收到WM_LBUTTONUP消息，该消息不在CControlBar::WindowProc特别处理的消息范围内，于是进行缺省处理，也就是说，把该消息派发给控制条对应的Windows控制的窗口过程处理（即被MFC统一窗口过程所取代的原窗口过程），该窗口过程则把该消息转换成一条命令消息WM_COMMAND，命令ID就是选中按钮对应的ID，然后，发送该命令消息给拥有工具条的边框窗口，导致相应的命令处理函数被调用。

　　对于对话框工具条，当工具条的某个控制子窗口被选中之后，则产生一条命令通知消息WM_COMMAND，wParam是控制子窗口的ID。CControlBar::WindowProc处理该消息。WindowProc首先调用OnWndMsg把消息发送给对话框工具条或者对话框工具条的基类处理，如果没有被处理的话，则OnWndMsg返回FALSE。接着，WindowPoc把命令消息传递给父窗口（边框窗口）处理。由于工具条的控制窗口的ID对应的是命令ID，所以，这条WM_COMMAND消息传递给边框窗口时，被解释成一个命令消息，相应的命令处理函数被调用。

PreTranslateMessage

　　CControlBar覆盖PreTranslateMessage函数，主要是为了在光标落在工具条按钮上时显示FLYBY信息，并且让对话框工具条过滤Dialog消息。

BOOL CControlBar::PreTranslateMessage(MSG* pMsg)
{
ASSERT_VALID(this);
ASSERT(m_hWnd != NULL);
//过滤Tooltip消息
if (CWnd::PreTranslateMessage(pMsg))
return TRUE; //是Tooltip消息，已经被处理
UINT message = pMsg->message;
//控制条的父窗口，对工具条和对话框工具条，总是创建它的边框窗口
CWnd* pOwner = GetOwner();
//必要的话，在状态条显示工具栏按钮的提示
if (((m_dwStyle & CBRS_FLYBY) ||
message == WM_LBUTTONDOWN || message == WM_LBUTTONUP) &&
((message >= WM_MOUSEFIRST && message <= WM_MOUSELAST) ||
(message >= WM_NCMOUSEFIRST &&
message <= WM_NCMOUSELAST)))
{
_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
//确认鼠标在工具栏的哪个按钮上
CPoint point = pMsg->pt;
ScreenToClient(&point);
TOOLINFO ti; memset(&ti, 0, sizeof(TOOLINFO));
ti.cbSize = sizeof(TOOLINFO);
int nHit = OnToolHitTest(point, &ti);
if (ti.lpszText != LPSTR_TEXTCALLBACK)
free(ti.lpszText);
BOOL bNotButton =
message == WM_LBUTTONDOWN && (ti.uFlags & TTF_NOTBUTTON);
if (message != WM_LBUTTONDOWN && GetKeyState(VK_LBUTTON) < 0)
nHit = pThreadState->m_nLastStatus;
//更新状态栏的提示信息
if (nHit < 0 || bNotButton)
{
if (GetKeyState(VK_LBUTTON) >= 0 || bNotButton)
{
SetStatusText(-1);
KillTimer(ID_TIMER_CHECK);
}
}
else
{
if (message == WM_LBUTTONUP)
{
SetStatusText(-1);
ResetTimer(ID_TIMER_CHECK, 200);
}
else
{
if ((m_nStateFlags & statusSet) || GetKeyState(VK_LBUTTON) < 0)
SetStatusText(nHit);
else if (nHit != pThreadState->m_nLastStatus)
ResetTimer(ID_TIMER_WAIT, 300);
}
}
pThreadState->m_nLastStatus = nHit;
}
// don't translate dialog messages when in Shift+F1 help mode
CFrameWnd* pFrameWnd = GetTopLevelFrame();
if (pFrameWnd != NULL && pFrameWnd->m_bHelpMode)
return FALSE;
//在IsDialogMessage之前调用边框窗口的PreTranslateMessage，
//给边框窗口一个处理快捷键的机会
while (pOwner != NULL)
{
// allow owner & frames to translate before IsDialogMessage does
if (pOwner->PreTranslateMessage(pMsg))
return TRUE;
// try parent frames until there are no parent frames
pOwner = pOwner->GetParentFrame();
}
//过滤给对话框的消息和来自子窗口的消息
return PreTranslateInput(pMsg);
}

　　函数PreTranslateMessage主要是针对工具栏的，用来处理工具栏的CBRS_FLYBY特征。

　　对于对话框工具栏，也可以有CBRS_FLYBY特征。但在这种情况下，还需要把一些用户键盘输入解释成对话框消息。为了防止快捷键被解释成对话框消息，在调用函数PreTranslateInput之前，必须调用所有父边框窗口的PreTranslateMessage，给父边框窗口一个机会处理用户的输入消息，判断快捷键是否被按下。

　　关于Tooltip和本PreTranslateMessage函数处理Tooltip的详细解释见下一节的讨论。

　　Tooltip

　　工具条（或对话框工具条）如果指定了CBRS_TOOLTIPS风格（创建时指定或者创建后用SetBarStyle设置），则当鼠标落在某个按钮上（或者对话框的子控制窗口）时，在鼠标附近弹出一个文本框──Tooltip提示窗口。

　　如果还指定了CBRS_FLYBY风格，则还在状态栏显示和按钮（或子控制窗口）ID对应的字符串信息。当然，鼠标左键在某个按钮（或子控制窗口）按下时，也要在状态栏显示按钮的提示信息，当左键弹起时，则重置状态栏的状态。

　　如前所述，Tooltip窗口是Windows控制窗口。MFC使用了CToolTipCtrl类封装Tooltip的HWND窗口。在一个线程的生存期间，至多拥有一个Tooltip窗口，该窗口对象的指针保存在线程状态的成员变量m_pToolTip中。线程状态类AFX_THREAD_STATE的析构函数如果检测到m_pToolTip，则销毁MFC窗口对象和相应的Windows窗口对象。

　　CWnd对Tooltip消息的预处理

　　为了支持Tooltip显示，CWnd提供了以下函数：EnableTooltip，CancelTooltip，PreTranslateMessage，FilterTooltipMessage，OnToolHitTest。

　　EnableTooltip设置CBRS_TOOLTIP风格，相反CancelTootip取消这种风格。

　　PreTranslateMessage调用了FilterTooltipMessage过滤Tooltip消息。

　　OnToolHitTest是一个由CWnd定义的虚拟函数。CToolBar通过覆盖该函数，来检测对话框工具栏的控制子窗口或者工具栏按钮是否被选中、哪个被选中。

　　CWnd的PreTranslateMessage在4.5节讨论过，它的实现如下：

BOOL CWnd::PreTranslateMessage(MSG* pMsg)
{
//处理Tooltip消息
AFX_MODULE_STATE* pModuleState = _AFX_CMDTARGET_GETSTATE();
if (pModuleState->m_pfnFilterToolTipMessage != NULL)
//导致调用FilterTooltipMessage
(*pModuleState->m_pfnFilterToolTipMessage)(pMsg, this);
//不是Tooltip消息
return FALSE;
}

　　至于为什么MFC在模块状态中保存一个处理Tooltip消息的函数地址，通过该函数调用FilterTooltipMessage，是因为Tooltip窗口是模块线程局部有效的。

FilterTooltipMessage检测是否是Tooltip消息。如果是，在必要时创建一个CTooltipCtrl对象和对应的HWND，调用OnToolHitTest确定被选中的按钮或者控制的ID，接着弹出Tooltip窗口。

　　其他函数和CTooltipCtrl这里不作详细论述了。

　　处理TTN_NEEDTEXT通知消息

　　Tooltip窗口在弹出之前，它给工具条（或者对话框工具栏）的父窗口发送通知消息TTN_NEEDTEXT，请求得到要显示的文本。

　　CFrameWnd类处理了TTN_NEEDTEXT通知消息，消息处理函数是OnToolTipText。

　　消息映射的定义：

　　ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)

　　ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)

　　这里，使用了扩展消息映射宏把子窗口ID在0和0xFFFF之间的控制条窗口的通知消息TTN_NEEDTEXTA和TTN_NEEDTEXTW映射到函数OnToolTipText。

　　消息映射的实现：

BOOL CFrameWnd::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
{
ASSERT(pNMHDR->code == TTN_NEEDTEXTA ||
pNMHDR->code == TTN_NEEDTEXTW);
//让上一层的边框窗口优先处理该消息
if (GetRoutingFrame() != NULL)
return FALSE;
//分ANSI and UNICODE两个处理版本
TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
TCHAR szFullText[256];
CString strTipText;
UINT nID = pNMHDR->idFrom;
//如果idFrom是一个子窗口，则得到其ID。
if (pNMHDR->code == TTN_NEEDTEXTA &&
(pTTTA->uFlags & TTF_IDISHWND) ||
pNMHDR->code == TTN_NEEDTEXTW &&
(pTTTW->uFlags & TTF_IDISHWND))
{
//idFrom是工具条的句柄
nID = _AfxGetDlgCtrlID((HWND)nID);
}
if (nID != 0) //若是0，为一分隔栏，不是按钮
{
//得到nID对应的字符串
AfxLoadString(nID, szFullText);
//从上面得到的字符串中取出Tooltip使用的文本
AfxExtractSubString(strTipText, szFullText, 1, '
');
}
//复制分离出的文本
#ifndef _UNICODE
if (pNMHDR->code == TTN_NEEDTEXTA)
lstrcpyn(pTTTA->szText, strTipText, _countof(pTTTA->szText));
else
_mbstowcsz(pTTTW->szText, strTipText, _countof(pTTTW->szText));
#else
if (pNMHDR->code == TTN_NEEDTEXTA)
_wcstombsz(pTTTA->szText, strTipText, _countof(pTTTA->szText));
else
lstrcpyn(pTTTW->szText, strTipText, _countof(pTTTW->szText));
#endif
*pResult = 0;
//显示Tooltip窗口
::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE);
return TRUE; //消息处理完毕
}

　　OnToolTipText是一个扩展映射宏定义的消息处理函数，所以有一个UINT参数并且返回BOOL类型的值。不过，由于第二个参数（NMHDR）的idFrom域包含了有关信息，所以第一个UINT类型的参数没有用上。

OnToolTipText也是一个处理通知消息的例子。其中，通知参数wParam的结构如4.4.4.2节所述，具体如下：typedef struct {
NMHDR hdr; //WM_NOTIFY消息要求的头
LPTSTR lpszText; //接收工具条按钮对应文本的缓冲区
WCHAR szText[80]; //接收Tooltip显示文本的缓冲区
HINSTANCE hinst; //包含了szText的实例句柄
UINT uflags; //标识了NMHDR的idFrom成员的意义
} TOOLTIPTEXT, FAR *LPTOOLTIPTEXT;

　　uflags如果等于TTF_IDISHWND，则表示通知消息来自对话框工具条的一个子窗口，而不是包含工具条按钮。

　　OnToolTipText根据子窗口ID或者工具条按钮对应的ID，得到字符串ID。如前所述，字符串ID由两部分组成，第二部分用于Tooltip显示，分隔符号是“ ”。根据这种格式OnToolTipText分离出Tooltip文本。

　　得到了Tooltip文本之后，可以有三种方法返回文本信息：把文本信息复制到szText缓冲区；把文本地址复制到lpszText；复制字符串资源的ID到lpszText、复制包含资源的实例句柄到hint。本函数采用了第一种方法。

　　在得到了返回的Tooltip文本之后，该文本在Tooltip窗口中被显示出来。

　　其他的OnToolHist等函数的实现不作详细的解释了。下面，讨论CBRS_FLYBY风格的实现。

　　CBRS_FLYBY风格的实现

　　CBRS_FLYBY是MFC提供的特征。当鼠标落在工具条按钮（或者对话框工具条的子窗口）上且稳定300ms后，在状态栏显示对应的提示信息。如果选中某个按钮或者子窗口（鼠标左键按下），则在相应命令消息处理之前在状态栏显示有关提示信息，之后（鼠标左键弹起），重新设置状态栏的状态信息。

　　为了支持这种特征，CControlBar覆盖虚拟函数PreTranslateMessage来处理和CBRS_FLYBY相关的消息，该函数前面已经讨论过，这里解释它如何处理CBRS_FLYBY特征。

　　如果同时具备

　　条件1：控制条具有CBRS_FLYBY特征或者当前消息是WM_LBUTTONUP或者WM_LBUTTONDOWN。

　　条件2：当前消息是鼠标消息（在WM_MOUSEFIRST和WM_MOUSELAST之间或者在WM_NCMOUSEFIRST和WM_NCMOUSELAST之间）。

　　则进行FLYBY处理。

　　首先，调用OnToolHitTest测试用户是否选中了工具条的按钮或者子窗口；

　　如果没有按钮或者子窗口被选中，则重新设置状态栏的状态，取消曾经设置的Check定时器。重置状态栏的状态时调用了SetStatusText（int nHit）函数，它是CControlBar内部使用的函数，若nHit等于-1，它向父窗口发送WM_POPMESSAGETEXT，消息参数是AFX_IDS_IDLEMESSAGE，结果导致状态栏显示“Ready”字样；否则发送WM_SETMESSAGETEXT消息，wParm设置为nHit，结果导致在状态栏显示ID为nHit的字符串。

如果有按钮或者子窗口被选中，若左键弹起，则重新设置状态栏信息，取消Wait定时器，并重新设置Check定时器，定时是200ms；若左键按下，则在状态栏显示消息ID对应的提示信息；若是其他鼠标消息，如果当前鼠标所在按钮（子窗口）不同于最近一次，则取消Check定时器，重新设置Wait定时器，定时300毫秒。

　　CControlBar覆盖了消息处理函数OnTimer，在指定时间之后，检查鼠标位置，如果鼠标还在某个按钮或者子窗口上，则在状态条显示提示信息。Wait定时器在等待之后准备在状态条显示信息，触发一次后被取消；Check定时器在等待之后，判断是否需要取消状态条当前显示的信息，重新设置状态条，若这样的话，同时也取消Check定时器。

　　注意，这些鼠标消息被处理之后，并没有终止，它们将继续被发送给控制条的窗口过程处理。

　　至此，CBRS_FLYBY特征的支持实现描述完毕。

　　禁止和允许

　　在MFC下，工具条、状态条还有一个重要的特征，就是自动地根据条件禁止或者允许使用某个按钮、窗格等。在4.4.5节命令消息的处理中，曾详细讨论了其实现原理，现在，详细地分析所涉及函数是如何实现的。有关的消息处理函数和虚拟函数如下。

　　处理WM_INITIALUPDATE消息的OnInitialUpdate；

　　处理WM_IDLEUPDATECMDUI消息的OnIdleUpdateCmdUI；

　　虚拟函数OnUpdateCmdUI。

　　回顾5.3.3.5节，在边框窗口的创建之后，给所有的子窗口发送初始化消息，控制子窗口用OnInitialUpdate响应它，调用OnIdleUpdateCmdUI完成状态的初始化。

　　OnIdleUpdateCmdUI还在IDLE处理时进行状态的更新处理，它生成用于处理状态更新消息的命令目标pTarget，然后调用虚拟函数OnUpdateCmdUI(pTarget，…)来更新工具栏或者状态栏的状态。

　　CControlBar的子类都实现了自己的OnUpdateCmdUI函数，用该函数生成适当的CCmdUI对象state，然后调用CCmdUI的DoUpdate（pTarget，…）给pTarget所指对象发送状态更新消息。为了完成具体的状态更新，从CCmdUI派生出CToolCmdUI和CStatusCCmUI，它们实现了自己的Enable、SetCheck等等。

　　初始化控制窗口

　　CControlBar使用OnInitialUpdate消息处理函数初始化控制窗口的状态。

void CControlBar::OnInitialUpdate()
{
//在窗口显示之前，更新状态
OnIdleUpdateCmdUI(TRUE, 0L);
}

　　CControlBar实现了OnInitialUpdate函数，通过它来处理WM_INITIALUPDATE消息。各个子类不必覆盖该消息处理函数。

　　处理Idle消息更新工具条状态

　　CControlBar使用OnIdleUpdateCmdUI消息处理函数处理IDLE消息。

LRESULT CControlBar::OnIdleUpdateCmdUI(WPARAM wParam, LPARAM)
{
// handle delay hide/show
BOOL bVis = GetStyle() & WS_VISIBLE;
UINT swpFlags = 0;
if ((m_nStateFlags & delayHide) && bVis)
swpFlags = SWP_HIDEWINDOW;
else if ((m_nStateFlags & delayShow) && !bVis)
swpFlags = SWP_SHOWWINDOW;
m_nStateFlags &= ~(delayShow|delayHide);
if (swpFlags != 0)
{
SetWindowPos(NULL, 0, 0, 0, 0, swpFlags|
SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
}
// the style must be visible and if it is docked
// the dockbar style must also be visible
if ((GetStyle() & WS_VISIBLE) &&
(m_pDockBar == NULL || (m_pDockBar->GetStyle() & WS_VISIBLE)))
{
//得到父边框窗口，状态更新消息将发送给它
CFrameWnd* pTarget = (CFrameWnd*)GetOwner();
if (pTarget == NULL || !pTarget->IsFrameWnd())
pTarget = GetParentFrame();
if (pTarget != NULL)
OnUpdateCmdUI(pTarget, (BOOL)wParam);
}
return 0L;
}

　　OnIdleUpdateCmdUI或者在初始化时被OnInitialUpdate调用，或者作为消息处理函数来处理WM_IDLEUPDATECMDUI消息。

　　CControlBar实现了OnIdleUpdateCmdUI函数，把具体的用户界面更新动作委托给虚拟函数OnUpdateCmdUI完成。

　　由于各个用户界面的特殊性，所以CControlBar本身没有实现OnUpdateCmdUI，而是留给各个派生类去实现。例如，CToolBar覆盖了OnUpdateCmdUI，其实现如下：

void CToolBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
{
//定义一个CCmdUI对象，CToolCmdUI派生于CCmdUI
CToolCmdUI state;
//给CCmdUI的各个成员赋值
state.m_pOther = this;
//得到总的按钮数目
state.m_nIndexMax = (UINT)DefWindowProc(TB_BUTTONCOUNT, 0, 0);
//逐个按钮进行状态更新
for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax; state.m_nIndex++)
{
//获取按钮状态信息
TBBUTTON button;
_GetButton(state.m_nIndex, &button);
//得到按钮的ID
state.m_nID = button.idCommand;
// ignore separators
if (!(button.fsStyle & TBSTYLE_SEP))
{
//优先让CToolBar对象处理状态更新消息
if (CWnd::OnCmdMsg(state.m_nID,
CN_UPDATE_COMMAND_UI, &state, NULL))
continue;//处理了更新消息，更新下一个按钮
//CToolBar没有处理，将发送给pTarget处理状态更新消息
//第二个参数bDisableIfNoHndler往下传
state.DoUpdate(pTarget, bDisableIfNoHndler);
}
}
//更新加到控制条中的对话框控制的状态
UpdateDialogControls(pTarget, bDisableIfNoHndler);
}

　　CToolBar的OnUpdateCmdUI函数完成工具条按钮的状态更新。它接受两个参数，参数1表示接收状态更新命令消息的对象，由CControlBar的函数OnIdleUpdateCmdUI传递过来，一般是边框窗口对象；参数2表示如果某条命令消息没有处理函数时，对应的用户接口对象是否被禁止。

OnUpdateCmdUI通过发送状态更新通知消息，逐个更新按钮的状态。更新消息首先让工具条对象处理，如果没有处理的话，送给边框窗口对象处理，导致状态更新命令消息的处理函数被调用，参见4.4.5节。

　　CStatusBar的OnUpdateCmdUI类似于此。

　　CDialogBar的OnUpdateCmdUI则调用了虚拟函数UpdateDialogControls来进行状态更新，CWnd提供了该函数的实现，过程类似于CToolBar的函数OnUpdateCmdUI。

　　菜单项的自动更新

　　那么，菜单项的自动更新如何实现的呢？OnInitMenuPopup在菜单项状态的自动更新中曾经被提到，其实现如下：

void CFrameWnd::OnInitMenuPopup(CMenu* pMenu, UINT, BOOL bSysMenu)
{
AfxCancelModes(m_hWnd);
if (bSysMenu)
return; // don't support system menu
ASSERT(pMenu != NULL);
// check the enabled state of various menu items
CCmdUI state;
state.m_pMenu = pMenu;
ASSERT(state.m_pOther == NULL);
ASSERT(state.m_pParentMenu == NULL);
//判断菜单是否在顶层菜单(top level menu)中弹出，如果这样
//则设置m_pParentMenu指向顶层菜单，否则m_pParentMenu
//为空，表示它是一个二级弹出菜单
HMENU hParentMenu;
//是否是浮动式的弹出菜单（floating pop up menu）
if (AfxGetThreadState()->m_hTrackingMenu == pMenu->m_hMenu)
state.m_pParentMenu = pMenu; // parent == child for tracking popup
else if ((hParentMenu = ::GetMenu(m_hWnd)) != NULL)//
{
CWnd* pParent = GetTopLevelParent();
// child windows don't have menus -- need to go to the top!
//得到顶层窗口的菜单
if (pParent != NULL &&
(hParentMenu = ::GetMenu(pParent->m_hWnd)) != NULL)
{
int nIndexMax = ::GetMenuItemCount(hParentMenu);
//确定顶层窗口的菜单是否包含本菜单项
for (int nIndex = 0; nIndex < nIndexMax; nIndex++)
{
if (::GetSubMenu(hParentMenu, nIndex) == pMenu->m_hMenu)
{
//顶层窗口菜单是本菜单的父菜单
state.m_pParentMenu = CMenu::FromHandle(hParentMenu);
break;
}
}
}
}
//本菜单的菜单项(menu item)数量
state.m_nIndexMax = pMenu->GetMenuItemCount();
//对所有菜单项逐个进行状态更新
for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax;
state.m_nIndex++)
{
state.m_nID = pMenu->GetMenuItemID(state.m_nIndex);
if (state.m_nID == 0)
continue; // menu separator or invalid cmd - ignore it
ASSERT(state.m_pOther == NULL);
ASSERT(state.m_pMenu != NULL);
if (state.m_nID == (UINT)-1)
{
// 可能是一个popup菜单，得到其第一个子菜单项目
state.m_pSubMenu = pMenu->GetSubMenu(state.m_nIndex);
if (state.m_pSubMenu == NULL ||
(state.m_nID = state.m_pSubMenu->GetMenuItemID(0)) == 0 ||
state.m_nID == (UINT)-1)
{
continue; // 找不到popup菜单的子菜单项
}
//popup菜单不会被自动的禁止
state.DoUpdate(this, FALSE);
}
else
{
//正常的菜单项，若边框窗口的m_bAutoMenuEnable设置为
//TURE且菜单项非系统菜单，则自动enable/disable该菜单项
state.m_pSubMenu = NULL;
state.DoUpdate(this, m_bAutoMenuEnable && state.m_nID < 0xF000);
}
//经过菜单状态的更新处理，可能增加或删除了一些菜单项
UINT nCount = pMenu->GetMenuItemCount();
if (nCount < state.m_nIndexMax)
{
state.m_nIndex -= (state.m_nIndexMax - nCount);
while (state.m_nIndex < nCount &&
pMenu->GetMenuItemID(state.m_nIndex) == state.m_nID)
{
state.m_nIndex++;
}
}
state.m_nIndexMax = nCount;
}
}

　　菜单弹出之前，发送WM_INITMENUPOPUP消息，OnInitMenuPopup消息处理函数被调用，逐个更新菜单项目（menu item）的状态。程序员可以处理它们对应的状态更新消息，禁止/允许菜单项目被使用（disable/enable)，在菜单项目上打钩或者取消（checked/unchecked），等等。

显示或者隐藏工具栏和状态栏

　　这里讨论显示或者隐藏工具栏、状态栏的操作，以及工具栏、状态栏被显示/隐藏时，相关的两个菜单项ID_VIEW_STATUS_BAR、ID_VIEW_TOOLBAR的状态更新。这两个菜单命令及对应的状态更新命令是标准命令消息所包含的。MFC边框窗口实现了菜单命令消息的处理和菜单项状态的更新。

　　CFrameWnd提供了OnBarCheck来响应与ID_VIEW_STATUS_BAR、ID_VIEW_TOOLBAR菜单项对应的命令。

　　消息映射：

　　ON_COMMAND_EX(ID_VIEW_STATUS_BAR, OnBarCheck)

　　ON_COMMAND_EX(ID_VIEW_TOOLBAR, OnBarCheck)

　　这里，使用了扩展命令消息映射宏把ID_VIEW_STATUS_BAR和ID_VIEW_TOOLBAR命令映射给同一个函数OnBarCheck处理。

　　OnBarCheck函数的实现：

BOOL CFrameWnd::OnBarCheck(UINT nID)
{
ASSERT(ID_VIEW_STATUS_BAR == AFX_IDW_STATUS_BAR);
ASSERT(ID_VIEW_TOOLBAR == AFX_IDW_TOOLBAR);
//得到工具条或者状态条
CControlBar* pBar = GetControlBar(nID);
if (pBar != NULL)
{
//若控制条可见，则隐藏它；否则，显示它
ShowControlBar(pBar, (pBar->GetStyle() & WS_VISIBLE) == 0, FALSE);
//处理完毕
return TRUE;
}
//可以让下一个命令目标继续处理
return FALSE;
}

　　由于是扩展映射宏定义的消息处理函数，所以OnBarCheck函数有一个UINT类型的参数和一个BOOL返回值。

　　当用户从“View”菜单选择打了钩的“Toolbar”时，消息处理函数OnBarCheck被调用，参数就是菜单项的ID号ID_VIEW_TOOLBAR，它等于工具条的子窗口IDAFX_IDW_TOOLBAR。处理结果，工具条被隐藏；当再次选择该菜单项则工具条被显示。

　　处理状态条的过程类似于工具条的处理。

　　ShowControlBar是CFrameWnd的成员函数，参数1表示控制条对象指针，参数2表示显示(TRUE)或者隐藏(FALSE)，参数3表示是立即显示（FALSE）或者延迟显示（TRUE）。

　　如果工具条或者状态条被隐藏，则相应的菜单项ID_VIEW_STATUS_BAR 或者ID_VIEW_TOOLBAR 变成uncheked（菜单项被标记为没有选择），否则，checked（菜单项被标记选择）。CFrameWnd实现了这两个菜单项的状态更新处理，列举其中一个如下：

　　声明处理ID_VIEW_TOOLBAR的状态更新消息：

　　ON_UPDATE_COMMAND_UI(ID_VIEW_TOOLBAR, OnUpdateControlBarMenu)

函数的实现：void CFrameWnd::OnUpdateControlBarMenu(CCmdUI* pCmdUI)
{
ASSERT(ID_VIEW_STATUS_BAR ==
AFX_IDW_STATUS_BAR);
ASSERT(ID_VIEW_TOOLBAR == AFX_IDW_TOOLBAR);
CControlBar* pBar = GetControlBar(pCmdUI->m_nID);
//存在工具栏
if (pBar != NULL)
{
//工具条窗口被显示则checked，被隐藏则uncheked
pCmdUI->SetCheck((pBar->GetStyle() & WS_VISIBLE) != 0);
return;
}
pCmdUI->ContinueRouting();
}

　　GetControlBar是CFrameWnd的成员函数，用来返回边框窗口的指定ID的控制条对象（指定ID是控制条的子窗口ID）。

　　泊位和漂浮

　　工具条可以泊位在边框窗口的任一边(上、下、左、右)，或者漂浮在屏幕上的任何地方。

　　实现泊位的方法

　　首先，边框窗口调用CFrameWnd::EnableDocking函数使控制条泊位在边框窗口中有效，指明在边框窗口的哪边接受泊位。如果想在任何边都可以泊位，则使用参数CBRS_ALIGN_ANY。

　　然后，工具条调用ControlBar::EnableDocking使泊位对工具条有效，如果在调用ControlBar::EnableDocking时指定的泊位目的边和边框窗口能够泊位的边不符合，那么工具条不能泊位，它将漂浮。

　　最后，边框窗口调用CFrameWnd::DockControlBar泊位工具条。

　　泊位后形成窗口层次关系

　　边框窗口、泊位条、工具条的包含关系如下：

　　边框窗口

　　泊位条1

　　工具条1

　　工具条2

　　…

　　泊位条2

　　…

　　边框窗口包含1到4个泊位条子窗口，每个泊位条包含若干个控制条子窗口。

　　泊位的实现

　　CFrameWnd::EnableDocking指定哪边接受泊位，则为泊位准备一个泊位条。泊位条用CDockBar描述，派生于CControlBar。如果指定任何边都可以泊位，则创建四个CDockBar对象和对应的HWND窗口。然后，调用ControlBar::EnableDocking在对应的泊位条内安置工具条。

　　MFC设计了CDockBar类和CFrameWnd的一些函数来实现泊位，具体代码实现在此不作详细讨论。

　　实现漂浮工具条的方法：

　　边框窗口调用FloatControlBar实现工具条的漂浮。

　　漂浮的实现：

　　首先，创建一个微型漂浮边框窗口，该边框窗口有一个泊位条。

　　然后，在微型边框窗口的泊位条内放置工具条。

　　MFC设计了微型边框类CMiniFrameWnd，在此基础上派生出微型泊位边框窗口类CMiniDockFrameWnd。CMiniDockFrameWnd增加了一个CDockBar类型成员变量m_wndDockBar，即泊位条。

在CMiniDockFrameWnd对象被创建时，创建泊位条m_wndDockBar。泊位条m_wndDockBar的父窗口如同CMiniDockFrameWnd的父窗口一样，是调用FloatControlBar的边框窗口，而不是微型泊位边框窗口。微型边框窗口和泊位条创建完成之后，调用ControlBar::DockControlBar泊位工具条在CMiniDockFrameWnd窗口。

　　具体的代码实现略。