menubar.cpp

这是一个串口监视程序

	bMaximized = bMax;

	return hWnd;
}
//******************************************************************
/////////////////////////////////////////////////////////////////////////////
// CMenuBar system hook
void CMenuBar::OnMenuSelect(HMENU hMenu, UINT nIndex)
{
//	LTRACE(_T("CMenuBar::OnMenuSelect\n"));
	if (m_nTrackingState == popup) {
		m_bProcessRightArrow = (::GetSubMenu(hMenu, nIndex) == NULL);
		HMENU hSubMenu = ::GetSubMenu(hMenu, m_nCurIndex);
		if (hSubMenu == NULL)
			return;
		m_bProcessLeftArrow = (hMenu == hSubMenu);
	}
}
//******************************************************************
void CMenuBar::OnFrameNcActivate(BOOL bActive) 
{
	CFrameWnd* pFrame = GetTopLevelFrame();
	ASSERT_VALID(pFrame);

	if (pFrame->m_nFlags & WF_STAYACTIVE)
		bActive = TRUE;
	if (!pFrame->IsWindowEnabled())
		bActive = FALSE;
	if (bActive == m_bFrameActive)
		return;

	if (!bActive) {
		for (int i = 0; i < GetItemCount(); ++i) {
			m_arrItem[i]->ModifyState(0, MISTATE_INACTIVE);
		}
	}
	else {
		for (int i = 0; i < GetItemCount(); ++i) {
			m_arrItem[i]->ModifyState(MISTATE_INACTIVE, 0);
		}
	}

	m_bFrameActive = bActive;

	// InvalidateRect(NULL); is better, but too late
	// while clicking the application title bar (like IE5)
	// so we have to redraw now!

}
//******************************************************************
LRESULT CALLBACK CMenuBar::MenuInputFilter(int code, WPARAM wParam, LPARAM lParam)
{
	return (
		code == MSGF_MENU &&
		g_pMenuBar &&
		g_pMenuBar->OnMenuInput( *((MSG*)lParam) )
		) ? TRUE : CallNextHookEx(g_hMsgHook, code, wParam, lParam);
}
//******************************************************************
void CMenuBar::TrackPopup(int nIndex)
{
	ASSERT_VALID(this);

	m_nCurIndex = nIndex;
	m_bLoop = TRUE;
	while (m_bLoop == TRUE) {
		UpdateWindow();	// force to repaint when button hidden by other window
		UpdateBar(popup, m_nCurIndex);
	
		// install hook
		ASSERT(g_pMenuBar == NULL);
		g_pMenuBar = this;
		ASSERT(g_hMsgHook == NULL);

		m_bLoop = FALSE;
		g_hMsgHook = ::SetWindowsHookEx(WH_MSGFILTER,
			MenuInputFilter, NULL, AfxGetApp()->m_nThreadID);// m_bLoop may become TRUE

		// popup!!
		m_nTrackingState = popup;
		_nPrevIndexForCmd = m_nCurIndex;
		m_arrItem[m_nCurIndex]->TrackPopup(this, GetTopLevelParent());

		// uninstall hook
		::UnhookWindowsHookEx(g_hMsgHook);
		g_hMsgHook = NULL;
		g_pMenuBar = NULL;
	}

	UpdateBar();
}

//******************************************************************
BOOL CMenuBar::OnMenuInput(MSG& m)
{
	ASSERT_VALID(this);
	int nMsg = m.message;
	CPoint pt = m.lParam;
	ScreenToClient(&pt);

	switch (nMsg) {
	case WM_MOUSEMOVE:
		if (pt != m_ptMouse) {
			int nIndex = HitTestOnTrack(pt);
			if ((IsValidIndex(nIndex) && nIndex != m_nCurIndex ) ) {
				// defferent button clicked
			//	Invalidate();
				if (!bActivSystemMenu)
					AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
				if (bActivSystemMenu)
					PostMessage(WM_CANCELMODE);
				UpdateBar(button, nIndex);
				UpdateBar();	
				bActivSystemMenu=FALSE;
				m_nCurIndex = nIndex;
				m_bLoop = TRUE;							// continue loop
			}
			m_ptMouse = pt;
		}
		break;

	case WM_LBUTTONDOWN:
		if ((HitTestOnTrack(pt) != -1 && HitTestOnTrack(pt) == m_nCurIndex)) {
			// same button clicked
			AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
			//PostMessage(WM_CANCELMODE);
			UpdateBar(button, m_nCurIndex);
			m_bLoop = FALSE;						// out of loop
			return TRUE;							// eat it!
		}
		break;
	
	
	case WM_KEYDOWN:	{
		TCHAR vKey = m.wParam;
		if (m_dwStyle & CBRS_ORIENT_VERT) {	// if vertical
			break; // do nothing
		}

		if ((vKey == VK_LEFT  && m_bProcessLeftArrow) ||
			(vKey == VK_RIGHT && m_bProcessRightArrow)) {
			// no submenu
			int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vKey==VK_LEFT);
			AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
			UpdateBar();
			m_nCurIndex = nNewIndex;
			m_bLoop = TRUE;							// continue loop			
			return TRUE;							// eat it!
		}
						}
		break;

	case WM_SYSKEYDOWN:
//		LTRACE(_T("    m_bIgnore = TRUE\n"));
		m_bIgnoreAlt = TRUE;					// next SysKeyUp will be ignored
		break;
	}

	return FALSE;	// pass along...
}

//******************************************************************
BOOL CMenuBar::TranslateFrameMessage(MSG* pMsg)
{
	ASSERT_VALID(this);
	ASSERT(pMsg);

	UINT nMsg = pMsg->message;
	if (WM_LBUTTONDOWN <= nMsg && nMsg <= WM_MOUSELAST) {
		if (pMsg->hwnd != m_hWnd && m_nTrackingState > 0) {
			// clicked outside
			UpdateBar();
		}
	}
	else if (nMsg == WM_SYSKEYDOWN || nMsg == WM_SYSKEYUP || nMsg == WM_KEYDOWN) {
		BOOL bAlt = HIWORD(pMsg->lParam) & KF_ALTDOWN;	// Alt key presed?
		TCHAR vkey = pMsg->wParam;						// + X key
		if (vkey == VK_MENU ||
			(vkey == VK_F10 && !((GetKeyState(VK_SHIFT) & 0x80000000) ||
			                   (GetKeyState(VK_CONTROL) & 0x80000000) || bAlt))) {
			// only alt key pressed
			if (nMsg == WM_SYSKEYUP) {
				switch (m_nTrackingState) {
				case none:
					if (m_bIgnoreAlt == TRUE) {
//						LTRACE(_T("    ignore ALT key up\n"));
						m_bIgnoreAlt = FALSE;
						break;
					}
				
					if (m_bMDIApp) {
						UpdateBar(button, GetNextOrPrevButton(0, FALSE));
					}
					else {
						UpdateBar(button, 0);
					}
					break;
				case button:
					UpdateBar();
					break;
				case buttonmouse:
					break;	// do nothing
				}
			}
			return TRUE;
		}
		else if ((nMsg == WM_SYSKEYDOWN || nMsg == WM_KEYDOWN)) {
			if (m_nTrackingState == button) {
				if (m_dwStyle & CBRS_ORIENT_HORZ) {	// if horizontal
					switch (vkey) {
					case VK_LEFT:
					case VK_RIGHT: {
						int nNewIndex  = GetNextOrPrevButton(m_nCurIndex, vkey == VK_LEFT);
						UpdateBar(button, nNewIndex);
						return TRUE;
								   }
					case VK_SPACE:
					case VK_UP:
					case VK_DOWN:
						TrackPopup(m_nCurIndex);
						return TRUE;

					case VK_ESCAPE:
						UpdateBar();
						return TRUE;
					}
				}
				else {								// if vertical
					switch (vkey) {
					case VK_UP:
					case VK_DOWN:{
						int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vkey == VK_UP);
						UpdateBar(button, nNewIndex);
						return TRUE;
								   }
					case VK_SPACE:
					case VK_RIGHT:
					case VK_LEFT:
						TrackPopup(m_nCurIndex);
						return TRUE;

					case VK_ESCAPE:
						UpdateBar();
						return TRUE;
					}
				}
			}

			// Alt + X pressed
			if ((bAlt || m_nTrackingState == button) && _istalnum(vkey)) {
				int nIndex;
				if (MapAccessKey(vkey, nIndex) == TRUE) {
					UpdateBar(button, nIndex);
					UpdateBar();
					TrackPopup(nIndex);
					return TRUE;		// eat it!
				}
				else if (m_nTrackingState==button && !bAlt) {
//					MessageBeep(0);		// if you want
					return TRUE;
				}
			}

			if (m_nTrackingState > 0) {	// unknown key
				if (m_nTrackingState != buttonmouse) {	// if tracked with mouse, don't update bar
					UpdateBar();
				}
			}
		}
	}
	return FALSE;	// pass along...
}

//******************************************************************
BOOL CMenuBar::MapAccessKey(TCHAR cAccessKey, int& nIndex)
{
	for (int i = 0; i < GetItemCount(); ++i) {
		// fixing point
		TCHAR cKey = m_arrItem[i]->GetAccessKey();
		if (toupper(cKey)/*_totupper(cKey)*/ == cAccessKey) {// *****fixed by andi, thanx!*****
			nIndex = i;
			return TRUE;
		}
	}
	return FALSE;
}

/////////////////////////////////////////////////////////////////////////////
// CMenuBar layout
int CMenuBar::GetClipBoxLength(BOOL bHorz)
{
	CFrameWnd* pFrame = GetTopLevelFrame(); ASSERT_VALID(pFrame);
	CRect rcFrame; pFrame->GetWindowRect(rcFrame);

	CWnd* pParent = GetParent(); ASSERT_VALID(pParent);
	CRect rcParent; pParent->GetWindowRect(rcParent);

	const int cxFrameBorder = ::GetSystemMetrics(SM_CXFRAME);
	int cxNonClient = cxFrameBorder*2 + m_cxLeftBorder + m_cxRightBorder;
	if (m_dwExStyle & CBRS_GRIPPER)
		cxNonClient += CX_GRIPPER_ALL;

	if (m_dwStyle & CBRS_SIZE_DYNAMIC) {
		if (bHorz) {
			return rcFrame.Width() - cxNonClient;
		}
		else {
			int nResult = rcParent.Height();
			// I don't know the reason of the following code...
			nResult -= m_cxRightBorder + m_cxLeftBorder + cyBorder2*2;	
			if (m_dwExStyle & CBRS_GRIPPER)
				nResult -= CY_GRIPPER_ALL;

			return nResult;
		}
	}
	else {
		CRect rect; GetClientRect(rect);
		if (bHorz) {
			return rect.Width();
		}
		else {
			return rect.Height();
		}
	}
}

//******************************************************************
CSize CMenuBar::CalcLayout(DWORD dwMode, int nLength)
{
	ASSERT_VALID(this);
	ASSERT(::IsWindow(m_hWnd));
	if (dwMode & LM_HORZDOCK)
		ASSERT(dwMode & LM_HORZ);

	// make SC_CLOSE button disable
	if (m_dwStyle & CBRS_FLOATING) {
		CFrameWnd* pMiniFrame = GetParentFrame(); ASSERT_KINDOF(CMiniFrameWnd, pMiniFrame);
//		Don't do this, cause right click menu turns unavairable
//		pMiniFrame->ModifyStyle(WS_SYSMENU, 0);
		CMenu* pSysMenu = pMiniFrame->GetSystemMenu(FALSE);	ASSERT_VALID(pSysMenu);
		pSysMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
	}

	int nCount = GetItemCount();
	CSize sizeResult(0, 0);

	if (nCount > 0)
	{
		if (!(m_dwStyle & CBRS_SIZE_FIXED))
		{
			BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;

			if (bDynamic && (dwMode & LM_MRUWIDTH))
			{
				LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_MRUWIDTH\n"));
				SizeMenuBar(m_nMRUWidth);
				CalcItemLayout(nCount);// added

				sizeResult = CalcSize(nCount);
			}
			else if (bDynamic && (dwMode & LM_HORZDOCK))
			{
				LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_HORZDOCK\n"));
				if (IsFloating() || (m_dwStyle & CBRS_ORIENT_VERT)) {
					// I can't synchronize horz size on dragging with size on dock bar
					// as VC++ developer can't.
					SizeMenuBar(32767);
				}
				else {
					// Menu Button wrapped by frame width
					SizeMenuBar(GetClipBoxLength(TRUE));
				}

				CalcItemLayout(nCount);// added
				
				sizeResult = CalcSize(nCount);
				if (!IsFloating() && !(m_dwStyle & CBRS_ORIENT_VERT)) {
					if (m_pDockContext->m_pDC) {// while dragging (m_pDockContext->m_bDragging is helpless)
						sizeResult.cx = GetClipBoxLength(TRUE);
					}
				}
			}
			else if (bDynamic && (dwMode & LM_VERTDOCK))
			{
				LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_VERTDOCK\n"));
				//SizeMenuBar(0);
				CalcItemLayout(nCount, TRUE);// added

				sizeResult = CalcVertDockSize(nCount);
				if (!IsFloating() && !(m_dwStyle & CBRS_ORIENT_HORZ)) {
					if (m_pDockContext->m_pDC) {// while dragging
						sizeResult.cy = GetClipBoxLength(FALSE);//GetrcParent.Height() - m_cxRightBorder - m_cxLeftBorder;
					}
				}
			}
			else if (bDynamic && (nLength != -1))
			{
				LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---nLength != -1\n"));
				CRect rect; rect.SetRectEmpty();
				_CalcInsideRect(rect, (dwMode & LM_HORZ));
				BOOL bVert = (dwMode & LM_LENGTHY);
				int nLen = nLength + (bVert ? rect.Height() : rect.Width());

				SizeMenuBar(nLen, bVert);
				CalcItemLayout(nCount, bVert);// added

				sizeResult = CalcSize(nCount);
			}
			else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
			{
				LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---CBRS_FLOATING\n"));
				SizeMenuBar(m_nMRUWidth);
				CalcItemLayout(nCount);// added

				sizeResult = CalcSize(nCount);
			}
			else
			{
				if (!bDynamic) {
					InvalidateRect(NULL);
					goto Junk;
				}

				LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---other\n"));
				BOOL bVert = !(dwMode & LM_HORZ);
				SizeMenuBar(GetClipBoxLength(TRUE));
				CalcItemLayout(nCount, bVert);// added

				if (bVert) {
					InvalidateRect(NULL);// draw forcefully for captions
					sizeResult = CalcVertDockSize(nCount);
					// DockBar not replaced yet, so I can't get precise size
					sizeResult.cy = 10000;
				}
				else {
					sizeResult = CalcSize(nCount);
					sizeResult.cx = GetClipBoxLength(TRUE);
				}
			}
		}
		else {// CBRS_SIZE_FIXED
			LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_FIXED)\n"));
Junk:
			BOOL bVert = !(dwMode & LM_HORZ);
			SizeMenuBar(32767);
			CalcItemLayout(nCount, bVert);// added

			if (bVert) {
				sizeResult = CalcVertDockSize(nCount);
			}
			else {
				sizeResult = CalcSize(nCount);
			}
		}

		if (dwMode & LM_COMMIT)
		{
			LTRACE(_T("CMenuBar::CalcLayout---LM_COMMIT\n"));
			int nControlCount = 0;
			BOOL bIsDelayed = m_bDelayedButtonLayout;
			m_bDelayedButtonLayout = FALSE;

			if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
				m_nMRUWidth = sizeResult.cx;

			CalcItemLayout(nCount, dwMode);

			m_bDelayedButtonLayout = bIsDelayed;
		}
	}

	//BLOCK: Adjust Margins
	{
		CRect rect; rect.SetRectEmpty();
		_CalcInsideRect(rect, (dwMode & LM_HORZ));