bcgppopupmenubar.cpp

关于远程网络监视程序的源码

		if (pMenuButton != NULL && pMenuButton->IsDroppedDown ())
		{
			CBCGPPopupMenu* pMenu = pMenuButton->m_pPopupMenu;
			if (pMenu != NULL && ::IsWindow (pMenu->m_hWnd))
			{
				pMenu->SaveState ();
				pMenu->PostMessage (WM_CLOSE);
			}
		}
	}

	CBCGPToolBar::OnDestroy();
}
//****************************************************************************************
BOOL CBCGPPopupMenuBar::OnKey(UINT nChar)
{
	BOOL bProcessed = FALSE;

	POSITION posSel = 
		(m_iHighlighted < 0) ? NULL : m_Buttons.FindIndex (m_iHighlighted);
	CBCGPToolbarButton* pOldSelButton = 
		(posSel == NULL) ? NULL : (CBCGPToolbarButton*) m_Buttons.GetAt (posSel);
	CBCGPToolbarButton* pNewSelButton = pOldSelButton;
	int iNewHighlight = m_iHighlighted;

	if (nChar == VK_TAB)
	{
		if (::GetKeyState(VK_SHIFT) & 0x80)
		{
			nChar = VK_UP;
		}
		else
		{
			nChar = VK_DOWN;
		}
	}

	switch (nChar)
	{
	case VK_RETURN:
		{
			bProcessed = TRUE;

			// Try to cascase a popup menu and, if failed 
			CBCGPToolbarMenuButton* pMenuButton = DYNAMIC_DOWNCAST (CBCGPToolbarMenuButton,
							pOldSelButton);
			if (pMenuButton != NULL &&
				!pMenuButton->OpenPopupMenu ())
			{
				GetOwner()->SendMessage(WM_SETMESSAGESTRING, AFX_IDS_IDLEMESSAGE);
				OnSendCommand (pMenuButton);
			}
		}
		break;

	case VK_HOME:
		posSel = NULL;
		// Like "Before first"...

	case VK_DOWN:
		//-----------------------------
		// Find next "selecteble" item:
		//-----------------------------
		{
			bProcessed = TRUE;
			if (m_Buttons.IsEmpty ())
			{
				break;
			}

			POSITION pos = posSel;
			if (pos != NULL)
			{
				m_Buttons.GetNext (pos);
			}

			if (pos == NULL)
			{
				pos = m_Buttons.GetHeadPosition ();
				iNewHighlight = 0;
			}
			else
			{
				iNewHighlight ++;
			}

			POSITION posFound = NULL;
			while (pos != posSel)
			{
				posFound = pos;

				CBCGPToolbarButton* pButton = (CBCGPToolbarButton*) m_Buttons.GetNext (pos);
				ASSERT_VALID (pButton);

				if ((pButton->m_nStyle & TBBS_SEPARATOR) == 0 &&
					!pButton->Rect ().IsRectEmpty ())
				{
					break;
				}

				iNewHighlight ++;
				if (pos == NULL)
				{
					pos = m_Buttons.GetHeadPosition ();
					iNewHighlight = 0;
				}
			}

			if (posFound != NULL)
			{
				pNewSelButton = (CBCGPToolbarButton*) m_Buttons.GetAt (posFound);
			}
		}
		break;

	case VK_END:
		posSel = NULL;
		// Like "After last"....

	case VK_UP:
		//---------------------------------
		// Find previous "selecteble" item:
		//---------------------------------
		{
			bProcessed = TRUE;
			if (m_Buttons.IsEmpty ())
			{
				break;
			}

			POSITION pos = posSel;
			if (pos != NULL)
			{
				m_Buttons.GetPrev (pos);
			}
			if (pos == NULL)
			{
				pos = m_Buttons.GetTailPosition ();
				iNewHighlight = m_Buttons.GetCount () - 1;
			}
			else
			{
				iNewHighlight --;
			}

			POSITION posFound = NULL;
			while (pos != posSel)
			{
				posFound = pos;

				CBCGPToolbarButton* pButton = (CBCGPToolbarButton*) m_Buttons.GetPrev (pos);
				ASSERT_VALID (pButton);

				if ((pButton->m_nStyle & TBBS_SEPARATOR) == 0 &&
					!pButton->Rect ().IsRectEmpty ())
				{
					break;
				}

				iNewHighlight --;
				if (pos == NULL)
				{
					pos = m_Buttons.GetTailPosition ();
					iNewHighlight = m_Buttons.GetCount () - 1;
				}
			}

			if (posFound != NULL)
			{
				pNewSelButton = (CBCGPToolbarButton*) m_Buttons.GetAt (posFound);
			}
		}
		break;

	default:
		// Process acceleration key:
		if (!IsCustomizeMode () &&
			(::GetAsyncKeyState (VK_CONTROL) & 0x8000) == 0)
		{
			// ----------------------------
			// Ensure the key is printable:
			// ----------------------------
			WORD wChar = 0;
			BYTE lpKeyState [256];
			::GetKeyboardState (lpKeyState);

			int nRes = ::ToAsciiEx (nChar,
						MapVirtualKey (nChar, 0),
						lpKeyState,
						&wChar,
						1,
						::GetKeyboardLayout (AfxGetThread()->m_nThreadID));

			BOOL bKeyIsPrintable = nRes > 0;

			UINT nUpperChar = nChar;
			if (bKeyIsPrintable)
			{
				nUpperChar = CBCGPKeyboardManager::TranslateCharToUpper (nChar);
			}

			CBCGPToolbarButton* pButton;
			if (bKeyIsPrintable && m_AcellKeys.Lookup (nUpperChar, pButton))
			{
				ASSERT_VALID (pButton);

				pNewSelButton = pButton;

				//-------------------
				// Find button index:
				//-------------------
				int iIndex = 0;
				for (POSITION pos = m_Buttons.GetHeadPosition ();
					pos != NULL; iIndex ++)
				{
					CBCGPToolbarButton* pListButton = (CBCGPToolbarButton*) m_Buttons.GetNext (pos);
					ASSERT (pListButton != NULL);

					if (pListButton == pButton)
					{
						iNewHighlight = iIndex;
						break;
					}
				}
				
				CBCGPToolbarMenuButton* pMenuButton =
					DYNAMIC_DOWNCAST (CBCGPToolbarMenuButton, pButton);

				if (pMenuButton != NULL)
				{
					if (pMenuButton->OpenPopupMenu ())
					{
						if (pMenuButton->m_pPopupMenu != NULL)
						{
							//--------------------------
							// Select a first menu item:
							//--------------------------
							pMenuButton->m_pPopupMenu->SendMessage (WM_KEYDOWN, VK_HOME);
						}
					}
					else
					{
						// If the newly selected item is not highlighted,
						// then make the menu go away.

						if ((pButton->m_nStyle & TBBS_DISABLED) != 0)
						{
							InvokeMenuCommand (0, pButton);
							return TRUE;
						}
						//-----------------------------------------

						bProcessed = OnSendCommand (pMenuButton);
						if (bProcessed)
						{
							return TRUE;
						}
					}
				}
			}
			else if (CBCGPMenuBar::m_bRecentlyUsedMenus &&
				!m_bAreAllCommandsShown)
			{
				///---------------------------------------------------
				// Maybe, this accelerator is belong to "hidden' item?
				//----------------------------------------------------
				UINT uiCmd = 0;
				if (m_HiddenItemsAccel.Lookup (nUpperChar, uiCmd))
				{
					InvokeMenuCommand (uiCmd, NULL);
					return TRUE;
				}
			}
		}
	}

	if (pNewSelButton != pOldSelButton)
	{
		ASSERT_VALID (pNewSelButton);
		ASSERT (iNewHighlight >= 0 && iNewHighlight < m_Buttons.GetCount ());
		ASSERT (GetButton (iNewHighlight) == pNewSelButton);

		if (IsCustomizeMode ())
		{
			m_iSelected = iNewHighlight;
		}

		m_iHighlighted = iNewHighlight;

		if (pOldSelButton != NULL)
		{
			InvalidateRect (pOldSelButton->Rect ());
		}

		InvalidateRect (pNewSelButton->Rect ());
		UpdateWindow ();

		if (pNewSelButton->m_nID != (UINT) -1)
		{
			ShowCommandMessageString (pNewSelButton->m_nID);
		}
	}

	return bProcessed;
}
//**************************************************************************************
void CBCGPPopupMenuBar::OnTimer(UINT nIDEvent) 
{
	CPoint ptCursor;
	::GetCursorPos (&ptCursor);
	ScreenToClient (&ptCursor);

	if (nIDEvent == uiPopupTimerEvent)
	{
		KillTimer (uiPopupTimerEvent);

		//---------------------------------
		// Remove current tooltip (if any):
		//---------------------------------
		if (m_ToolTip.GetSafeHwnd () != NULL)
		{
			m_ToolTip.ShowWindow (SW_HIDE);
		}

		if (m_pDelayedClosePopupMenuButton != NULL &&
			m_pDelayedClosePopupMenuButton->Rect ().PtInRect (ptCursor))
		{
			return;
		}

		CloseDelayedSubMenu ();

		CBCGPToolbarMenuButton* pDelayedPopupMenuButton = m_pDelayedPopupMenuButton;
		m_pDelayedPopupMenuButton = NULL;

		if (pDelayedPopupMenuButton != NULL &&
			m_iHighlighted >= 0 &&
			m_iHighlighted < m_Buttons.GetCount () &&
			GetButton (m_iHighlighted) == pDelayedPopupMenuButton)
		{
			ASSERT_VALID (pDelayedPopupMenuButton);
			pDelayedPopupMenuButton->OpenPopupMenu (this);
		}
	}
	else if (nIDEvent == uiRemovePopupTimerEvent)
	{
		KillTimer (uiRemovePopupTimerEvent);

		if (m_pDelayedClosePopupMenuButton != NULL)
		{
			ASSERT_VALID (m_pDelayedClosePopupMenuButton);
			CBCGPPopupMenu* pParentMenu = DYNAMIC_DOWNCAST (CBCGPPopupMenu, GetParent ());

			if (m_pDelayedClosePopupMenuButton->Rect ().PtInRect (ptCursor))
			{
				return;
			}

			m_pDelayedClosePopupMenuButton->OnCancelMode ();
			m_pDelayedClosePopupMenuButton = NULL;

			if (pParentMenu != NULL)
			{
				CBCGPPopupMenu::ActivatePopupMenu (BCGCBProGetTopLevelFrame (this), pParentMenu);
			}
		}
	}
}
//**************************************************************************************
void CBCGPPopupMenuBar::StartPopupMenuTimer (CBCGPToolbarMenuButton* pMenuButton,
											int nDelayFactor/* = 1*/)
{
	ASSERT (nDelayFactor > 0);

	if (m_pDelayedPopupMenuButton != NULL)
	{
		KillTimer (uiPopupTimerEvent);
	}

	if ((m_pDelayedPopupMenuButton = pMenuButton) != NULL)
	{
		if (m_pDelayedPopupMenuButton == m_pDelayedClosePopupMenuButton)
		{
			RestoreDelayedSubMenu ();
			m_pDelayedPopupMenuButton = NULL;
		}
		else
		{
			SetTimer (uiPopupTimerEvent, m_uiPopupTimerDelay * nDelayFactor, NULL);
		}
	}
}
//**********************************************************************************
void CBCGPPopupMenuBar::OnLButtonDown(UINT nFlags, CPoint point) 
{
	m_bFirstClick = FALSE;
	m_bIsClickOutsideItem = TRUE;

	CRect rectClient;
	GetClientRect (&rectClient);

	if (!IsCustomizeMode () && 
		!rectClient.PtInRect (point))
	{
		CBCGPToolBar* pDestBar = FindDestBar (point);
		if (pDestBar != NULL)
		{
			ASSERT_VALID (pDestBar);

			CPoint ptDest = point;
			MapWindowPoints (pDestBar, &ptDest, 1);

			pDestBar->SendMessage (	WM_LBUTTONDOWN, 
									nFlags, 
									MAKELPARAM (ptDest.x, ptDest.y));
		}
	}

	CBCGPToolBar::OnLButtonDown(nFlags, point);
}
//**********************************************************************************
void CBCGPPopupMenuBar::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CRect rectClient;
	GetClientRect (&rectClient);

	if (!m_bFirstClick &&
		!IsCustomizeMode () && 
		!rectClient.PtInRect (point))
	{
		CBCGPToolBar* pDestBar = FindDestBar (point);
		if (pDestBar != NULL)
		{
			MapWindowPoints (pDestBar, &point, 1);
			pDestBar->SendMessage (	WM_LBUTTONUP, 
									nFlags, 
									MAKELPARAM (point.x, point.y));
		}

		CFrameWnd* pParentFrame = BCGPGetParentFrame (this);
		ASSERT_VALID (pParentFrame);

		pParentFrame->DestroyWindow ();
		return;
	}

	if (!IsCustomizeMode () && m_iHighlighted >= 0)
	{
		m_iButtonCapture = m_iHighlighted;
	}

	m_bFirstClick = FALSE;
	if (m_bIsClickOutsideItem)
	{
		CBCGPToolBar::OnLButtonUp (nFlags, point);
	}
}
//**********************************************************************************
BOOL CBCGPPopupMenuBar::OnSetDefaultButtonText (CBCGPToolbarButton* pButton)
{
	ASSERT_VALID (pButton);

	CBCGPPopupMenu* pParentMenu = DYNAMIC_DOWNCAST (CBCGPPopupMenu, GetParent ());
	if (pParentMenu != NULL)
	{
		CBCGPToolBar* pToolBar = pParentMenu->GetParentToolBar ();
		if (pToolBar != NULL && pToolBar->OnSetDefaultButtonText (pButton))
		{
			return TRUE;
		}
	}

	return CBCGPToolBar::OnSetDefaultButtonText (pButton);
}
//****************************************************************************************
BOOL CBCGPPopupMenuBar::EnableContextMenuItems (CBCGPToolbarButton* pButton, CMenu* pPopup)
{
	if (!CBCGPToolBar::IsCustomizeMode ())
	{
		// Disable context menu
		return FALSE;
	}

	ASSERT_VALID (pButton);
	ASSERT_VALID (pPopup);

	pButton->m_bText = TRUE;
	CBCGPToolBar::EnableContextMenuItems (pButton, pPopup);

	pPopup->EnableMenuItem (ID_BCGBARRES_TOOLBAR_IMAGE, MF_GRAYED | MF_BYCOMMAND);

	if (pButton->m_bImage && pButton->GetImage () >= 0)
	{
		pPopup->EnableMenuItem (ID_BCGBARRES_TOOLBAR_TEXT, MF_ENABLED | MF_BYCOMMAND);
		pPopup->EnableMenuItem (ID_BCGBARRES_TOOLBAR_IMAGE_AND_TEXT, MF_ENABLED | MF_BYCOMMAND);

		if (CMD_MGR.IsMenuItemWithoutImage (pButton->m_nID))
		{
			pPopup->CheckMenuItem (ID_BCGBARRES_TOOLBAR_TEXT, MF_CHECKED  | MF_BYCOMMAND);
			pPopup->CheckMenuItem (ID_BCGBARRES_TOOLBAR_IMAGE_AND_TEXT, MF_UNCHECKED  | MF_BYCOMMAND);
		}
	}

	return TRUE;
}
//****************************************************************************************