Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-31 22:25:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5aec84d6a2
gecko-dev/cmd/winfe/dropmenu.cpp
hyatt%netscape.com 1b5b8fb32a Landing the WinFE RDF branch.
1998-07-23 17:48:39 +00:00

2624 lines
60 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
// dropmenu.cpp
// Implements a popup menu in which you can drag and drop
#include "stdafx.h"
#include "dropmenu.h"
#define nIMG_SPACE 4
#define MAX_DROPMENU_ITEM_LENGTH 45
//////////////////////////////////////////////////////////////////////////
// Class CDropMenuButton
//////////////////////////////////////////////////////////////////////////
CDropMenuButton::CDropMenuButton(void)
{
m_bButtonPressed = FALSE;
m_bMenuShowing = FALSE;
m_bFirstTime = FALSE;
}
//////////////////////////////////////////////////////////////////////////
// Messages for CDropMenuButton
//////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(CDropMenuButton, CStationaryToolbarButton)
//{{AFX_MSG_MAP(CWnd)
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_MOUSEMOVE()
ON_MESSAGE(DM_MENUCLOSED, OnMenuClosed)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
void CDropMenuButton::OnLButtonDown(UINT nFlags, CPoint point)
{
CStationaryToolbarButton::OnLButtonDown(nFlags, point);
m_bButtonPressed = TRUE;
}
void CDropMenuButton::OnMouseMove(UINT nFlags, CPoint point)
{
if(m_bMenuShowing)
{
if(m_bFirstTime)
{
ReleaseCapture();
m_eState = eBUTTON_DOWN;
RedrawWindow();
m_bFirstTime = FALSE;
}
}
else
{
CStationaryToolbarButton::OnMouseMove(nFlags, point);
}
}
void CDropMenuButton::OnLButtonUp(UINT nFlags, CPoint point)
{
if(m_bButtonPressed && m_bEnabled && m_bHaveFocus)
{
OnAction();
m_bMenuShowing = TRUE;
m_bFirstTime = TRUE;
}
else
{
CStationaryToolbarButton::OnLButtonUp(nFlags, point);
m_bMenuShowing = FALSE;
}
m_bButtonPressed = FALSE;
}
LRESULT CDropMenuButton::OnMenuClosed(WPARAM wParam, LPARAM lParam)
{
m_bMenuShowing = FALSE;
m_eState = eNORMAL;
RedrawWindow();
return 1;
}
//////////////////////////////////////////////////////////////////////////
// Class CDropMenuItem
//////////////////////////////////////////////////////////////////////////
CDropMenuItem::CDropMenuItem(UINT nFlags, CString szText, UINT nCommandID,
HBITMAP hUnselectedBitmap, HBITMAP hSelectedBitmap,
BOOL bShowFeedback, void *pUserData)
{
m_nIconType = BUILTIN_BITMAP;
if(nFlags & MF_SEPARATOR)
{
m_bIsSeparator = TRUE;
}
else if(nFlags == MF_STRING)
{
m_bIsSeparator = FALSE;
char *pCutText = fe_MiddleCutString(szText.GetBuffer(szText.GetLength() + 1), MAX_DROPMENU_ITEM_LENGTH);
m_szText = pCutText;
szText.ReleaseBuffer();
free(pCutText);
m_hUnselectedBitmap = hUnselectedBitmap;
m_hSelectedBitmap = (hSelectedBitmap == NULL) ? hUnselectedBitmap : hSelectedBitmap;
m_nCommandID = nCommandID;
m_pSubMenu = NULL;
}
m_bIsEmpty = TRUE;
m_unselectedBitmapSize.cx = m_unselectedBitmapSize.cy = 0;
m_selectedBitmapSize.cx = m_selectedBitmapSize.cy = 0;
m_textSize.cx = m_textSize.cy = 0;
m_totalSize.cx = m_totalSize.cy = 0;
m_menuItemRect.SetRectEmpty();
m_bShowFeedback = bShowFeedback;
m_pUserData = pUserData;
}
CDropMenuItem::CDropMenuItem(UINT nFlags, CString szText, UINT nCommandID, CDropMenu *pSubMenu, BOOL bIsEmpty,
HBITMAP hUnselectedBitmap, HBITMAP hSelectedBitmap, BOOL bShowFeedback, void *pUserData)
{
if(nFlags & MF_POPUP)
{
m_bIsSeparator = FALSE;
char *pCutText = fe_MiddleCutString(szText.GetBuffer(szText.GetLength() + 1), MAX_DROPMENU_ITEM_LENGTH);
m_szText = pCutText;
szText.ReleaseBuffer();
free(pCutText);
m_hUnselectedBitmap = hUnselectedBitmap;
m_hSelectedBitmap = (hSelectedBitmap == NULL) ? hUnselectedBitmap : hSelectedBitmap;
m_nCommandID = nCommandID;
m_pSubMenu = pSubMenu;
}
m_bIsEmpty = bIsEmpty;
m_unselectedBitmapSize.cx = m_unselectedBitmapSize.cy = 0;
m_selectedBitmapSize.cx = m_selectedBitmapSize.cy = 0;
m_textSize.cx = m_textSize.cy = 0;
m_totalSize.cx = m_totalSize.cy = 0;
m_menuItemRect.SetRectEmpty();
m_bShowFeedback = bShowFeedback;
m_pUserData = pUserData;
}
CDropMenuItem::~CDropMenuItem()
{
if(IsSubMenu())
{
CDropMenu *pSubMenu = GetSubMenu();
pSubMenu->DestroyDropMenu();
delete pSubMenu;
}
}
void CDropMenuItem::GetMenuItemRect(LPRECT rect)
{
rect->left = m_menuItemRect.left;
rect->right = m_menuItemRect.right;
rect->top = m_menuItemRect.top;
rect->bottom = m_menuItemRect.bottom;
}
void CDropMenuItem::SetMenuItemRect(LPRECT rect)
{
m_menuItemRect.left = rect->left;
m_menuItemRect.right = rect->right;
m_menuItemRect.top = rect->top;
m_menuItemRect.bottom = rect->bottom;
}
///////////////////////////////////////////////////////////////////////////
// Class CDropMenuDropTarget
///////////////////////////////////////////////////////////////////////////
CDropMenuDropTarget::CDropMenuDropTarget(CWnd *pOwner)
{
m_pOwner = pOwner;
}
DROPEFFECT CDropMenuDropTarget::OnDragEnter(CWnd * pWnd, COleDataObject * pDataObject,
DWORD dwKeyState, CPoint point)
{
return OnDragOver(pWnd, pDataObject, dwKeyState, point);
}
DROPEFFECT CDropMenuDropTarget::OnDragOver(CWnd * pWnd, COleDataObject * pDataObject,
DWORD dwKeyState, CPoint point )
{
CDropMenuDragData dragData(pDataObject, point);
m_pOwner->SendMessage(DT_DRAGGINGOCCURRED, (WPARAM) 0, (LPARAM)(&dragData));
return dragData.m_DropEffect;
}
BOOL CDropMenuDropTarget::OnDrop(CWnd * pWnd, COleDataObject * pDataObject,
DROPEFFECT dropEffect, CPoint point)
{
CDropMenuDragData* dragData = new CDropMenuDragData(pDataObject, point);
m_pOwner->SendMessage(DT_DROPOCCURRED, (WPARAM) 0, (LPARAM)(dragData));
return TRUE;
}
// End CDropMenuDropTarget implementation
// CDropMenuColumn
CDropMenuColumn::CDropMenuColumn(int nFirstItem, int nLastItem, int nWidth, int nHeight)
{
m_nFirstItem = nFirstItem;
m_nLastItem = nLastItem;
m_nWidth = nWidth;
m_nHeight = nHeight;
m_bHasSubMenu = FALSE;
}
#define NOSELECTION -1
#define MENU_BORDER_SIZE 3
#define SUBMENU_WIDTH 9
#define SUBMENU_HEIGHT 11
#define SUBMENU_LEFT_MARGIN 3
#define SUBMENU_RIGHT_MARGIN 7
#define IDT_SUBMENU_OFF 16384
#define SUBMENU_DELAY_OFF_MS 400
#define IDT_SUBMENU_ON 16385
#define SUBMENU_DELAY_ON_MS 400
#define IDT_HAVE_FOCUS 16386
#define HAVE_FOCUS_DELAY 400
#define IDT_UNHOOK 16387
#define UNHOOK_DELAY 100
#define SEPARATOR_SPACE 2
#define SEPARATOR_HEIGHT 2
#define SEPARATOR_WIDTH 2
#define SPACE_BETWEEN_ITEMS 2
static HHOOK currentMouseHook;
static HHOOK currentKeyboardHook;
static CDropMenu * currentMenu = NULL; //This refers to a submenu of the current dropmenu
static CDropMenu * gLastMenu = NULL; //This refers to the most recent complete dropmenu
static LONG oldFrameProc;
static UINT gUnhookTimer = 0;
CDropMenu* CDropMenu::GetLastDropMenu()
{
return gLastMenu;
}
void CDropMenu::SetLastDropMenu(CDropMenu* menu)
{
gLastMenu = menu;
}
CDropMenu::CDropMenu()
{
m_pMenuItemArray.SetSize(0, 10);
m_WidestImage = 0;
m_WidestText = 0;
m_nSelectedItem = -1;
m_eSelectedItemSelType = eNONE;
m_bShowing = FALSE;
m_pDropTarget = NULL;
m_pUnselectedItem = NULL;
m_pSelectedItem = NULL;
m_nSelectTimer = 0;
m_nUnselectTimer = 0;
m_pMenuParent = NULL;
m_pShowingSubmenu = NULL;
m_bDropOccurring = FALSE;
m_bDragging = FALSE;
m_bRight = TRUE;
m_bMouseUsed = TRUE;
m_bIsOpen = FALSE;
m_pOverflowMenuItem = NULL;
m_bAboutToShow = FALSE;
m_pParentMenuItem = NULL;
m_hSubmenuUnselectedBitmap = NULL;
m_hSubmenuSelectedBitmap = NULL;
m_pUserData = NULL;
}
CDropMenu::~CDropMenu()
{
// Clear out any dangling pointers.
if(currentMenu == this) {
currentMenu = NULL;
}
if(gLastMenu == this) {
gLastMenu = NULL;
}
int nCount = m_pMenuItemArray.GetSize();
for(int i = 0; i < nCount; i++)
{
CDropMenuItem *pItem = (CDropMenuItem *)m_pMenuItemArray[i];
if(pItem != m_pOverflowMenuItem)
delete pItem;
}
int nColumnCount = m_pColumnArray.GetSize();
for(int j = 0 ; j < nColumnCount; j++)
delete (CDropMenuColumn*)m_pColumnArray[j];
if(m_pDropTarget)
delete m_pDropTarget;
if(m_pOverflowMenuItem != NULL)
delete m_pOverflowMenuItem;
m_pMenuItemArray.RemoveAll();
if(m_pMenuParent == NULL)
{
if(m_hSubmenuSelectedBitmap != NULL)
{
::DeleteObject(m_hSubmenuSelectedBitmap);
m_hSubmenuSelectedBitmap = NULL;
}
if(m_hSubmenuUnselectedBitmap != NULL)
{
::DeleteObject(m_hSubmenuUnselectedBitmap);
m_hSubmenuUnselectedBitmap = NULL;
}
}
if(m_pMenuParent != NULL && m_pMenuParent->m_pShowingSubmenu == this)
m_pMenuParent->m_pShowingSubmenu = NULL;
m_pMenuParent = NULL;
m_bShowing = FALSE;
}
UINT CDropMenu::GetMenuItemCount(void)
{
return m_pMenuItemArray.GetSize();
}
void CDropMenu::AppendMenu(UINT nFlags, UINT nIDNewItem, CString szText, BOOL bShowFeedback,
HBITMAP hUnselectedBitmap, HBITMAP hSelectedBitmap,
void* icon, IconType iconType, void *pUserData)
{
CDropMenuItem *pMenuItem = new CDropMenuItem(nFlags, szText, nIDNewItem,
hUnselectedBitmap, hSelectedBitmap, bShowFeedback, pUserData);
pMenuItem->SetIcon(icon, iconType);
m_pMenuItemArray.Add(pMenuItem);
}
void CDropMenu::AppendMenu(UINT nFlags, UINT nIDNewItem, CDropMenu *pSubMenu, BOOL bIsEmpty, CString szText,
BOOL bShowFeedback, HBITMAP hUnselectedBitmap, HBITMAP hSelectedBitmap,
void* icon, IconType iconType, void *pUserData)
{
CDropMenuItem *pMenuItem = new CDropMenuItem(nFlags, szText, nIDNewItem, pSubMenu, bIsEmpty,
hUnselectedBitmap, hSelectedBitmap, bShowFeedback, pUserData);
pMenuItem->SetIcon(icon, iconType);
m_pMenuItemArray.Add(pMenuItem);
}
void CDropMenu::DeleteMenu(UINT nPosition, UINT nFlags)
{
CDropMenuItem *pItem;
if(nFlags == MF_BYPOSITION)
{
UINT nCount = m_pMenuItemArray.GetSize();
if(nPosition >= 0 && nPosition < nCount)
{
pItem = (CDropMenuItem *)m_pMenuItemArray[nPosition];
m_pMenuItemArray.RemoveAt(nPosition, 1);
}
}
else if(nFlags == MF_BYCOMMAND)
{
int nCommandPosition = FindCommand(nPosition);
if(nCommandPosition != -1)
{
pItem = (CDropMenuItem *)m_pMenuItemArray[nCommandPosition];
m_pMenuItemArray.RemoveAt(nCommandPosition, 1);
}
}
if(pItem != m_pOverflowMenuItem)
delete pItem;
}
void CDropMenu::CreateOverflowMenuItem(UINT nCommand, CString szText, HBITMAP hUnselectedBitmap, HBITMAP hSelectedBitmap)
{
m_pOverflowMenuItem = new CDropMenuItem(MF_STRING, szText, nCommand, hUnselectedBitmap,
hSelectedBitmap, FALSE);
}
LRESULT CALLBACK EXPORT HandleMouseEvents(int nCode, WPARAM wParam, LPARAM lParam)
{
if(nCode < 0)
return CallNextHookEx(currentMouseHook, nCode, wParam, lParam);
MOUSEHOOKSTRUCT *mouseHook = (MOUSEHOOKSTRUCT*)lParam;
if(currentMenu != NULL)
{
//only want to deactivate if point is not in our menu or in our parent or children
if(nCode >= 0 && (wParam == WM_NCLBUTTONDOWN || wParam == WM_LBUTTONDOWN ||
((wParam == WM_LBUTTONUP || wParam == WM_NCLBUTTONUP) && currentMenu->IsDragging())))
{
if(currentMenu != NULL && !currentMenu->PointInMenus(mouseHook->pt))
{
currentMenu->Deactivate();
}
}
}
return CallNextHookEx(currentMouseHook, nCode, wParam, lParam);
}
LRESULT CALLBACK EXPORT HandleKeyboardEvents(int nCode, WPARAM wParam, LPARAM lParam)
{
if(nCode < 0)
{
return CallNextHookEx(currentKeyboardHook, nCode, wParam, lParam);
}
//only want to handle on a keydown
if(!(HIWORD(lParam) & KF_UP) && currentMenu != NULL)
{
currentMenu->HandleKeystroke(wParam);
}
//we don't want to pass the keyboard event onwards
return 1;
}
LRESULT CALLBACK EXPORT FrameProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if(uMsg == WM_ACTIVATE)
{
if(LOWORD(wParam) == WA_INACTIVE && !currentMenu->IsShowingMenu((HWND)lParam))
{
currentMenu->Deactivate();
}
}
return CallWindowProc((WNDPROC)oldFrameProc, hWnd, uMsg, wParam, lParam);
}
// oppX and oppY refer to the x and y coordinates if the menu has to open in the opposite direction. Default is to not use them
void CDropMenu::TrackDropMenu(CWnd *pParent, int x, int y, BOOL bDragging, CDropMenuDropTarget *pDropTarget, BOOL bShowFeedback, int oppX, int oppY)
{
if(!m_bShowing)
{
m_bShowFeedback = bShowFeedback;
m_bDragging = bDragging;
m_bHasSubMenu = FALSE;
m_pParent = pParent;
m_bFirstPaint =TRUE;
if(m_pMenuParent != NULL)
{
m_bRight = m_pMenuParent->m_bRight;
}
// m_bNotDestroyed = TRUE;
if(GetMenuItemCount() == 0)
GetTopLevelParent()->SendMessage(DM_FILLINMENU, 0, (LPARAM)this);
m_bShowing = TRUE;
m_bAboutToShow = FALSE;
m_bIsOpen = TRUE;
if(m_hSubmenuUnselectedBitmap == NULL)
m_hSubmenuUnselectedBitmap = ::LoadBitmap(AfxGetResourceHandle(), MAKEINTRESOURCE(IDB_SUBMENU1));
if(m_hSubmenuSelectedBitmap == NULL)
m_hSubmenuSelectedBitmap = ::LoadBitmap(AfxGetResourceHandle(), MAKEINTRESOURCE(IDB_SUBMENU2));
if(!::IsWindow(m_hWnd))
{
CWnd::CreateEx(0, AfxRegisterWndClass( CS_SAVEBITS ,
theApp.LoadStandardCursor(IDC_ARROW),
(HBRUSH)(COLOR_MENU + 1), NULL),"test", WS_POPUP , 0, 0, 0,0, pParent->m_hWnd, NULL, NULL);
SetDropMenuTarget(pDropTarget);
}
else delete pDropTarget;
CSize size = GetMenuSize();
CPoint startPoint = FindStartPoint(x, y, size, oppX, oppY);
if(m_pMenuParent == NULL)
{
if(gLastMenu !=NULL)
{
//we only want one drop menu open at a time, so close the last one if one is
//still open. This will probably only happen on drag and drop.
gLastMenu->Deactivate();
}
oldFrameProc = SetWindowLong(GetParentFrame()->m_hWnd, GWL_WNDPROC, (LONG)FrameProc);
#ifdef _WIN32
currentMouseHook = SetWindowsHookEx(WH_MOUSE, HandleMouseEvents, AfxGetInstanceHandle(), GetCurrentThreadId());
currentKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, HandleKeyboardEvents, AfxGetInstanceHandle(),GetCurrentThreadId());
#else
currentMouseHook = SetWindowsHookEx(WH_MOUSE, HandleMouseEvents, AfxGetInstanceHandle(), GetCurrentTask());
currentKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, HandleKeyboardEvents, AfxGetInstanceHandle(), GetCurrentTask());
#endif
gLastMenu = this;
}
SetWindowPos(NULL, startPoint.x, startPoint.y,
size.cx + (2*MENU_BORDER_SIZE), size.cy + (2 * MENU_BORDER_SIZE),
SWP_NOZORDER | SWP_NOACTIVATE);
ShowWindow(SW_SHOWNA);
//SetActiveWindow();
}
else delete pDropTarget;
}
void CDropMenu::SetDropMenuTarget(CDropMenuDropTarget *pDropTarget)
{
m_pDropTarget = pDropTarget;
DragAcceptFiles();
m_pDropTarget->Register(this);
}
BOOL CDropMenu::PointInMenus(POINT pt)
{
CRect rect;
GetWindowRect(&rect);
if(rect.PtInRect(pt))
{
return TRUE;
}
else
{
CDropMenu *menu = m_pMenuParent;
while(menu != NULL && IsWindow(menu->m_hWnd))
{
menu->GetWindowRect(&rect);
if(rect.PtInRect(pt))
{
return TRUE;
}
menu=menu->m_pMenuParent;
}
menu = m_pShowingSubmenu;
while(menu !=NULL && IsWindow(menu->m_hWnd))
{
menu->GetWindowRect(&rect);
if(rect.PtInRect(pt))
{
return TRUE;
}
menu = menu->m_pShowingSubmenu;
}
}
return FALSE;
}
void CDropMenu::HandleKeystroke(WPARAM key)
{
//Make all open windows know that we are in keyboard mode still
CDropMenu *pMenu = this;
while(pMenu != NULL)
{
pMenu->m_bMouseUsed = FALSE;
pMenu = pMenu->m_pMenuParent;
}
if(key == VK_ESCAPE || !m_bDragging)
{
switch(key)
{
case VK_ESCAPE: currentMenu->Deactivate();
break;
case VK_UP: HandleUpArrow();
break;
case VK_DOWN: HandleDownArrow();
break;
case VK_LEFT: HandleLeftArrow();
break;
case VK_RIGHT: HandleRightArrow();
break;
case VK_RETURN: HandleReturnKey();
}
}
}
BOOL CDropMenu::OnCommand( WPARAM wParam, LPARAM lParam )
{
ShowWindow(SW_HIDE);
m_pParent->SendMessage(WM_COMMAND, wParam, lParam);
return 1;
}
BOOL CDropMenu::DestroyWindow(void)
{
return(CWnd::DestroyWindow());
}
void CDropMenu::Deactivate(void)
{
if(m_pMenuParent != NULL)
{
m_pMenuParent->SendMessage(DM_CLOSEALLMENUS, 0, 0);
}
ShowWindow(SW_HIDE);
}
BOOL CDropMenu::ShowWindow( int nCmdShow )
{
if(nCmdShow == SW_HIDE && IsWindowVisible())
{
m_bIsOpen = FALSE;
if(m_pMenuParent != NULL)
{
//Turn on parent's focus timer
m_pMenuParent->m_nHaveFocusTimer = m_pMenuParent->SetTimer(IDT_HAVE_FOCUS, HAVE_FOCUS_DELAY, NULL);
// we only want the parent to be the current menu if the parent hasn't already
// brought up a new submenu. Otherwise we have timing conflicts
if(m_pMenuParent->m_bShowing &&
(m_pMenuParent->m_pShowingSubmenu == this || m_pMenuParent->m_pShowingSubmenu == NULL))
{
currentMenu = m_pMenuParent;
}
}
KillTimer(m_nHaveFocusTimer);
//if this is the top level parent then the hook needs to be destroyed
if(m_pMenuParent == NULL)
{
UnhookWindowsHookEx(currentMouseHook);
UnhookWindowsHookEx(currentKeyboardHook);
SetWindowLong(GetParentFrame()->m_hWnd, GWL_WNDPROC, (LONG)oldFrameProc);
currentMenu = NULL;
gLastMenu = NULL;
}
OnTimer(IDT_SUBMENU_OFF);
m_bShowing = FALSE;
m_nSelectedItem = -1;
if(m_pShowingSubmenu)
{
//check to see if it's valid first because we may
//want to deactivate before it was created due to
//the timer never having been called to create it
if(IsWindow(m_pShowingSubmenu->m_hWnd))
{
m_pShowingSubmenu->ShowWindow(SW_HIDE);
}
m_pShowingSubmenu = NULL;
}
if(m_pMenuParent == NULL)
{
m_pParent->PostMessage(DM_MENUCLOSED, 0, 0);
}
}
else if(nCmdShow == SW_SHOWNA)
{
if(m_pMenuParent != NULL)
{
//since we are being shown, turn off parent's focus timer
m_pMenuParent->KillTimer(m_nHaveFocusTimer);
}
m_nHaveFocusTimer = SetTimer(IDT_HAVE_FOCUS, HAVE_FOCUS_DELAY, NULL);
currentMenu = this;
}
return CWnd::ShowWindow(nCmdShow);
}
void CDropMenu::PostNcDestroy(void )
{
CWnd::PostNcDestroy();
}
void CDropMenu::DestroyDropMenu(void)
{
DestroyWindow();
}
//////////////////////////////////////////////////////////////////////////
// Messages for CDropMenu
//////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(CDropMenu, CWnd)
//{{AFX_MSG_MAP(CWnd)
ON_WM_PAINT()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_RBUTTONDOWN()
ON_WM_MOUSEMOVE()
ON_WM_NCHITTEST()
ON_MESSAGE(DT_DROPOCCURRED, OnDropTargetDropOccurred)
ON_MESSAGE(DT_DRAGGINGOCCURRED, OnDropTargetDraggingOccurred)
ON_MESSAGE(DM_CLOSEALLMENUS, OnCloseAllMenus)
ON_WM_TIMER()
ON_WM_ACTIVATE()
ON_WM_DESTROY()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
void CDropMenu::OnPaint()
{
CRect updateRect;
if(GetUpdateRect(&updateRect))
{
CPaintDC dcPaint(this); // device context for painting
CRect rcClient;
GetClientRect(&rcClient);
HDC hSrcDC = dcPaint.m_hDC;
HDC hMemDC = ::CreateCompatibleDC(hSrcDC);
HBITMAP hbmMem = CreateCompatibleBitmap(hSrcDC,
rcClient.Width(),
rcClient.Height());
//
// Select the bitmap into the off-screen DC.
//
COLORREF rgbOldBk = ::SetBkColor(hMemDC, sysInfo.m_clrMenu);
HBITMAP hbmOld = (HBITMAP)::SelectObject(hMemDC, hbmMem);
HBRUSH brFace = sysInfo.m_hbrMenu;
::FillRect(hMemDC, rcClient, brFace);
CRect intersectRect;
int nNumColumns = m_pColumnArray.GetSize();
int nFirstItem, nLastItem;
CDropMenuColumn *pColumn;
int nStartX = 0;
for(int j = 0; j <=m_nLastVisibleColumn; j++)
{
int y = MENU_BORDER_SIZE;
pColumn = (CDropMenuColumn*)m_pColumnArray[j];
nFirstItem = pColumn->GetFirstItem();
nLastItem = pColumn->GetLastItem();
for(int i = nFirstItem; i <= nLastItem; i++)
{
CDropMenuItem *item = (CDropMenuItem*)m_pMenuItemArray[i];
if(m_bShowFeedback)
y += SPACE_BETWEEN_ITEMS;
if(item->IsSeparator())
{
CRect separatorRect(nStartX + MENU_BORDER_SIZE, y, nStartX + MENU_BORDER_SIZE + pColumn->GetWidth(), y + SEPARATOR_SPACE * 2 + SEPARATOR_HEIGHT);
if(intersectRect.IntersectRect(separatorRect, updateRect))
{
DrawSeparator(hMemDC, separatorRect.left, y, separatorRect.Width() - (2 * MENU_BORDER_SIZE));
}
y += SEPARATOR_SPACE * 2 + SEPARATOR_HEIGHT;
}
else
{
CRect itemRect;
item->GetMenuItemRect(itemRect);
if(intersectRect.IntersectRect(itemRect, updateRect))
{
CRect rect(nStartX + MENU_BORDER_SIZE, y ,nStartX + MENU_BORDER_SIZE + pColumn->GetWidth(), y + itemRect.Height());
DrawItem(pColumn, item, rect, hMemDC, i == m_nSelectedItem,
(i == m_nSelectedItem) ? m_eSelectedItemSelType : eNONE);
}
y += itemRect.Height();
}
}
nStartX += pColumn->GetWidth();
if(j < m_nLastVisibleColumn)
{
DrawVerticalSeparator(hMemDC, nStartX, MENU_BORDER_SIZE, rcClient.Height() - (2 * MENU_BORDER_SIZE));
nStartX += SEPARATOR_WIDTH;
}
}
// need to make sure selection type shows up
if(m_nSelectedItem != NOSELECTION && m_eSelectedItemSelType != eNONE)
{
CRect itemRect;
CDropMenuItem *item = (CDropMenuItem*)m_pMenuItemArray[m_nSelectedItem];
if(!item->IsSeparator())
{
item->GetMenuItemRect(itemRect);
CRect rect(itemRect.left, itemRect.top ,itemRect.left + ((CDropMenuColumn*)m_pColumnArray[item->GetColumn()])->GetWidth(), itemRect.top + itemRect.Height());
DrawItem((CDropMenuColumn*)m_pColumnArray[item->GetColumn()], item, rect, hMemDC, TRUE, m_eSelectedItemSelType );
}
}
DrawBorders(hMemDC, rcClient);
::BitBlt(hSrcDC, 0, 0, rcClient.Width(), rcClient.Height(), hMemDC, 0, 0,
SRCCOPY);
::SetBkColor(hMemDC, rgbOldBk);
::SelectObject(hMemDC, hbmOld);
::DeleteObject(hbmMem);
::DeleteDC(hMemDC);
}
if(m_bFirstPaint)
{
MSG msg;
PeekMessage(&msg, this->m_hWnd, WM_LBUTTONUP, WM_LBUTTONUP, PM_REMOVE);
m_bFirstPaint = FALSE;
}
}
void CDropMenu::OnMouseMove(UINT nFlags, CPoint point)
{
if(!m_bMouseUsed)
{
m_bMouseUsed = TRUE;
return;
}
m_bMouseUsed = TRUE;
KeepMenuAroundIfClosing();
ChangeSelection(point);
}
UINT CDropMenu::OnNcHitTest( CPoint point )
{
return CWnd::OnNcHitTest(point);
}
void CDropMenu::OnLButtonUp(UINT nFlags, CPoint point)
{
//if we haven't painted yet then the user hasn't had a chance to mouse up.
if(m_bFirstPaint || m_nSelectedItem == NOSELECTION)
return;
MenuSelectionType eSelType;
int nSelection = FindSelection(point, eSelType);
if(nSelection != -1)
{
CDropMenuItem *pItem = (CDropMenuItem *)m_pMenuItemArray[nSelection];
if(!pItem->IsSubMenu())
{
SendMessage(WM_COMMAND, (WPARAM) pItem->GetCommand(), (LPARAM) m_hWnd);
}
}
}
void CDropMenu::OnLButtonDown(UINT nFlags, CPoint point)
{
// we want our frame to stay the active window. Causes flicker
GetParentFrame()->SetActiveWindow();
}
void CDropMenu::OnRButtonDown(UINT nFlags, CPoint point)
{
// we want our frame to stay the active window. Causes flicker
GetParentFrame()->SetActiveWindow();
}
LRESULT CDropMenu::OnDropTargetDraggingOccurred(WPARAM wParam, LPARAM lParam)
{
if (wParam == 0)
{
CDropMenuDragData* pData = (CDropMenuDragData*)lParam;
KeepMenuAroundIfClosing();
ChangeSelection(pData->m_PointHit);
// Ok, now we need to figure out what our drag feedback should be.
// note that point is already in our coordinates since we got it from our drop target
MenuSelectionType eSelType;
int nSelection = FindSelection(pData->m_PointHit, eSelType);
if(nSelection != -1)
{
CDropMenuItem *pItem = (CDropMenuItem *)m_pMenuItemArray[nSelection];
pData->m_nCommand = pItem->GetCommand();
pData->eSelType = eSelType;
m_pParent->SendMessage(DT_DRAGGINGOCCURRED, 1, lParam);
}
}
else
{
m_pParent->SendMessage(DT_DRAGGINGOCCURRED, 1, lParam);
}
return 1;
}
LRESULT CDropMenu::OnDropTargetDropOccurred(WPARAM wParam, LPARAM lParam)
{
if (wParam == 0)
{
CDropMenuDragData* pData = (CDropMenuDragData*)lParam;
// Ok, now we need to figure out what our drag feedback should be.
// note that point is already in our coordinates since we got it from our drop target
MenuSelectionType eSelType;
int nSelection = FindSelection(pData->m_PointHit, eSelType);
if(nSelection != -1)
{
CDropMenuItem *pItem = (CDropMenuItem *)m_pMenuItemArray[nSelection];
pData->m_nCommand = pItem->GetCommand();
pData->eSelType = eSelType;
m_pParent->SendMessage(DT_DROPOCCURRED, 1, lParam);
}
}
else
{
m_pParent->SendMessage(DT_DROPOCCURRED, 1, lParam);
}
ShowWindow(SW_HIDE);
return 1;
}
LRESULT CDropMenu::OnCloseAllMenus(WPARAM wParam, LPARAM lParam)
{
if(m_pMenuParent != NULL)
{
m_pMenuParent->PostMessage(DM_CLOSEALLMENUS, wParam, lParam);
}
ShowWindow(SW_HIDE);
return 1;
}
void CDropMenu::OnTimer( UINT nIDEvent )
{
if(nIDEvent == IDT_SUBMENU_OFF)
{
KillTimer(m_nUnselectTimer);
if(m_pUnselectedItem != NULL && m_pUnselectedItem->GetSubMenu()->m_bShowing==FALSE)
{
m_pUnselectedItem->GetSubMenu()->ShowWindow(SW_HIDE);
}
m_pUnselectedItem = NULL;
}
else if(nIDEvent == IDT_SUBMENU_ON)
{
KillTimer(m_nSelectTimer);
if(m_bShowing)
{
if(m_pSelectedItem)
{
CDropMenu *pSubMenu = m_pSelectedItem->GetSubMenu();
if(pSubMenu && pSubMenu->m_bAboutToShow)
ShowSubmenu(m_pSelectedItem);
else
m_pSelectedItem = NULL;
}
m_nSelectTimer = 0;
}
}
else if(nIDEvent == IDT_HAVE_FOCUS)
{
if(m_nSelectedItem != -1 && m_bMouseUsed)
{
CDropMenuItem *pItem = (CDropMenuItem*)m_pMenuItemArray[m_nSelectedItem];
CPoint point;
GetCursorPos(&point);
ScreenToClient(&point);
CRect rcClient, rect;
GetClientRect(rcClient);
if (!rcClient.PtInRect(point) && m_pShowingSubmenu == NULL )
{
pItem->GetMenuItemRect(rect);
rect.left = 0;
rect.right = rcClient.right;
m_nSelectedItem = -1;
InvalidateRect(&rect);
}
}
}
}
void CDropMenu::OnActivate( UINT nState, CWnd* pWndOther, BOOL bMinimized )
{
if(nState == WA_ACTIVE)
{
pWndOther->SetActiveWindow();
}
}
void CDropMenu::OnDestroy( )
{
m_pDropTarget->Revoke();
CWnd::OnDestroy();
}
//////////////////////////////////////////////////////////////////////////
// Helpers for CDropMenu
//////////////////////////////////////////////////////////////////////////
void CDropMenu::DrawSeparator(HDC hDC, int x, int y, int nWidth)
{
HPEN pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW));
HPEN pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined (WIN32)
::MoveToEx(hDC, x, y + SEPARATOR_SPACE, NULL);
#else
::MoveTo(hDC, x, y + SEPARATOR_SPACE);
#endif
::LineTo(hDC, x + nWidth, y + SEPARATOR_SPACE);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
#if defined(WIN32)
pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHILIGHT));
#else
pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT));
#endif
pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined(WIN32)
::MoveToEx(hDC, x, y + SEPARATOR_SPACE + 1, NULL);
#else
::MoveTo(hDC, x, y + SEPARATOR_SPACE + 1);
#endif
::LineTo(hDC, x + nWidth, y + SEPARATOR_SPACE + 1);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
}
void CDropMenu::DrawVerticalSeparator(HDC hDC, int x, int y, int nHeight)
{
HPEN pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW));
HPEN pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined (WIN32)
::MoveToEx(hDC, x + SEPARATOR_SPACE, y, NULL);
#else
::MoveTo(hDC, x + SEPARATOR_SPACE, y);
#endif
::LineTo(hDC, x + SEPARATOR_SPACE, y + nHeight);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
#if defined(WIN32)
pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHILIGHT));
#else
pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT));
#endif
pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined(WIN32)
::MoveToEx(hDC, x + SEPARATOR_SPACE + 1, y, NULL);
#else
::MoveTo(hDC, x + SEPARATOR_SPACE + 1, y);
#endif
::LineTo(hDC, x + SEPARATOR_SPACE + 1, y + nHeight);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
}
void CDropMenu::DrawBorders(HDC hDC, CRect rcClient)
{
//Draw inner rect which is all BTN_FACE
RECT rect;
::SetRect(&rect, rcClient.left + 2, rcClient.top + 2, rcClient.right - 2, rcClient.bottom - 2);
::FrameRect(hDC, &rect, sysInfo.m_hbrBtnFace);
#if defined(WIN32)
HPEN pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHILIGHT));
#else
HPEN pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT));
#endif
HPEN pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined(WIN32)
::MoveToEx(hDC, rcClient.left + 1, rcClient.bottom - 1, NULL);
#else
::MoveTo(hDC, rcClient.left + 1, rcClient.bottom - 1);
#endif
::LineTo(hDC, rcClient.left + 1, rcClient.top + 1);
::LineTo(hDC, rcClient.right - 1, rcClient.top + 1);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNFACE));
pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined(WIN32)
::MoveToEx(hDC, rcClient.left, rcClient.bottom - 1, NULL);
#else
::MoveTo(hDC, rcClient.left, rcClient.bottom - 1);
#endif
::LineTo(hDC, rcClient.left, rcClient.top);
::LineTo(hDC, rcClient.right - 1, rcClient.top);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
pen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined(WIN32)
::MoveToEx(hDC, rcClient.right - 1, rcClient.top, NULL);
#else
::MoveTo(hDC, rcClient.right - 1, rcClient.top);
#endif
::LineTo(hDC, rcClient.right - 1 , rcClient.bottom - 1);
::LineTo(hDC, rcClient.left - 1, rcClient.bottom - 1);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
pen = ::CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW));
pOldPen = (HPEN)::SelectObject(hDC, pen);
#if defined(WIN32)
::MoveToEx(hDC, rcClient.right - 2, rcClient.top + 1, NULL);
#else
::MoveTo(hDC, rcClient.right - 2, rcClient.top + 1);
#endif
::LineTo(hDC, rcClient.right - 2, rcClient.bottom - 2);
::LineTo(hDC, rcClient.left, rcClient.bottom -2);
::SelectObject(hDC, pOldPen);
::DeleteObject(pen);
}
void CDropMenu::DrawItem(CDropMenuColumn *pColumn, CDropMenuItem *pItem, CRect rc, HDC hDC, BOOL bIsSelected, MenuSelectionType eSelType)
{
// Extract the goods from lpDI
ASSERT(pItem != NULL);
// Get proper colors and paint the background first
COLORREF rgbTxt;
HBRUSH brFace;
COLORREF rgbOldBk;
if (bIsSelected && (eSelType == eNONE || eSelType == eON))
{
rgbOldBk = ::SetBkColor(hDC, sysInfo.m_clrHighlight);
brFace = sysInfo.m_hbrHighlight;
rgbTxt = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
}
else
{
rgbOldBk = ::SetBkColor(hDC, sysInfo.m_clrMenu);
brFace = sysInfo.m_hbrMenu;
rgbTxt = ::GetSysColor(COLOR_MENUTEXT);
}
::FillRect(hDC, rc, brFace);
if(eSelType == eABOVE)
DrawSeparator(hDC, rc.left, rc.top - SEPARATOR_SPACE - 2, rc.Width() / 2);
else if(eSelType == eBELOW)
DrawSeparator(hDC, rc.left, rc.bottom - SEPARATOR_HEIGHT - SEPARATOR_SPACE + 2, rc.Width() / 2);
CDC *pDC = CDC::FromHandle(hDC);
// Now paint the bitmap, left side of menu
rc.left += nIMG_SPACE;
CSize imgSize = DrawImage(pDC, rc, pColumn, pItem, bIsSelected, eSelType);
// And now the text
HFONT MenuFont;
#if defined(WIN32)
NONCLIENTMETRICS ncm;
ncm.cbSize = sizeof(NONCLIENTMETRICS);
if (::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0))
{
MenuFont = theApp.CreateAppFont( ncm.lfMenuFont );
}
else
{
MenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
}
#else // Win16
MenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
#endif // WIN32
HFONT pOldFont = (HFONT)::SelectObject(hDC, MenuFont);
int nOldBkMode = ::SetBkMode(hDC, TRANSPARENT);
COLORREF rgbOldTxt = ::SetTextColor(hDC, rgbTxt);
//Figure out where text should go in relation to bitmaps
rc.left += imgSize.cx + nIMG_SPACE + (pColumn->GetWidestImage()-imgSize.cx);
//Deal with the case where there is a tab for an accelerator
CString label=pItem->GetText();
DrawText(hDC, (const char*)label, -1, &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE |DT_EXPANDTABS);
::SetBkMode(hDC, nOldBkMode);
::SetTextColor(hDC, rgbOldTxt);
::SelectObject(hDC, pOldFont);
#if defined(WIN32)
if (::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0))
{
theApp.ReleaseAppFont(MenuFont);
}
#endif
// Draw submenu bitmap
if(pItem->IsSubMenu() && !pItem->IsEmpty())
{
HBITMAP pSubmenuBitmap;
if(bIsSelected && (eSelType == eNONE || eSelType == eON))
{
pSubmenuBitmap = m_hSubmenuSelectedBitmap;
}
else
{
pSubmenuBitmap = m_hSubmenuUnselectedBitmap;
}
// Create a scratch DC and select our bitmap into it.
HDC pBmpDC = CreateCompatibleDC(hDC);
HBITMAP pOldBmp = (HBITMAP)::SelectObject(pBmpDC, pSubmenuBitmap);
// Center the image horizontally and vertically
CPoint ptDst(rc.right - SUBMENU_WIDTH - SUBMENU_RIGHT_MARGIN, rc.top +
(((rc.Height() - SUBMENU_HEIGHT) + 1) / 2));
// Call the handy transparent blit function to paint the bitmap over
// the background.
::FEU_TransBlt(hDC, ptDst.x, ptDst.y,SUBMENU_WIDTH, SUBMENU_HEIGHT,
pBmpDC, 0, 0, WFE_GetUIPalette(GetParentFrame()),RGB(255, 0, 255) );
// Cleanup
::SelectObject(pBmpDC, pOldBmp);
::DeleteDC(pBmpDC);
}
::SetBkColor(hDC, rgbOldBk);
} // END OF FUNCTION CDropMenu::DrawItem()
/****************************************************************************
*
* CDropMenu::DrawImage
*
* PARAMETERS:
* pDC - pointer to device context to draw on
* rect - bounding rectangle to draw in
* pItem - pointer to CDropMenuItem that contains the data
* bIsSelected - whether this item is selected
*
* RETURNS:
* width of the image, in pixels
*
* DESCRIPTION:
* Protected helper function for drawing the bitmap image in a menu
* item. We return the size of the painted image so the caller can
* position the menu text after the image.
*
****************************************************************************/
CSize CDropMenu::DrawImage(CDC * pDC, const CRect & rect, CDropMenuColumn *pColumn, CDropMenuItem * pItem, BOOL bIsSelected,
MenuSelectionType eSelType)
{
CSize sizeImg;
sizeImg.cx = sizeImg.cy = 0;
HBITMAP hImg = (bIsSelected && (!m_bShowFeedback || eSelType == eON || eSelType == eNONE)) ?
pItem->GetSelectedBitmap() : pItem->GetUnselectedBitmap();
if (hImg != NULL)
{
// Get image dimensions
BITMAP bmp;
GetObject(hImg, sizeof(bmp), &bmp);
sizeImg.cx = bmp.bmWidth;
sizeImg.cy = bmp.bmHeight;
// Create a scratch DC and select our bitmap into it.
HDC hBmpDC = ::CreateCompatibleDC(pDC->m_hDC);
HBITMAP hOldBmp = (HBITMAP)SelectObject(hBmpDC, hImg);
// Center the image horizontally and vertically
CPoint ptDst(rect.left + (pColumn->GetWidestImage() - sizeImg.cx)/2, rect.top +
(((rect.Height() - sizeImg.cy) + 1) / 2));
// Call the handy transparent blit function to paint the bitmap over
// the background.
if (pItem->GetIconType() == LOCAL_FILE)
{
HICON hIcon = pItem->GetLocalFileIcon();
DrawIconEx(pDC->m_hDC, ptDst.x, ptDst.y, hIcon, 0, 0, 0, NULL, DI_NORMAL);
}
else if (pItem->GetIconType() == ARBITRARY_URL)
{
CRDFImage* pImage = pItem->GetCustomIcon();
HDC hDC = pDC->m_hDC;
int left = ptDst.x;
int top = ptDst.y;
int imageWidth = 16;
int imageHeight = 16;
COLORREF bkColor = (bIsSelected && (!m_bShowFeedback || eSelType == eON || eSelType == eNONE)) ?
GetSysColor(COLOR_HIGHLIGHT) : GetSysColor(COLOR_MENU);
if (pImage && pImage->FrameLoaded())
{
// Now we draw this bad boy.
if (pImage->m_BadImage)
{
// display broken icon.
HDC tempDC = ::CreateCompatibleDC(hDC);
HBITMAP hOldBmp = (HBITMAP)::SelectObject(tempDC, CRDFImage::m_hBadImageBitmap);
::StretchBlt(hDC,
left, top,
imageWidth, imageHeight,
tempDC, 0, 0,
imageWidth, imageHeight, SRCCOPY);
::SelectObject(tempDC, hOldBmp);
::DeleteDC(tempDC);
}
else if (pImage->bits )
{
// Center the image.
long width = pImage->bmpInfo->bmiHeader.biWidth;
long height = pImage->bmpInfo->bmiHeader.biHeight;
int xoffset = (imageWidth-width)/2;
int yoffset = (imageHeight-height)/2;
if (xoffset < 0) xoffset = 0;
if (yoffset < 0) yoffset = 0;
if (width > imageWidth) width = imageWidth;
if (height > imageHeight) height = imageHeight;
HPALETTE hPal = WFE_GetUIPalette(NULL);
HPALETTE hOldPal = ::SelectPalette(hDC, hPal, TRUE);
::RealizePalette(hDC);
if (pImage->maskbits)
{
WFE_StretchDIBitsWithMask(hDC, TRUE, NULL,
left+xoffset, top+xoffset,
width, height,
0, 0, width, height,
pImage->bits, pImage->bmpInfo,
pImage->maskbits, FALSE, bkColor);
}
else
{
::StretchDIBits(hDC,
left+xoffset, top+xoffset,
width, height,
0, 0, width, height, pImage->bits, pImage->bmpInfo, DIB_RGB_COLORS,
SRCCOPY);
}
::SelectPalette(hDC, hOldPal, TRUE);
}
}
}
else ::BitBlt(pDC->m_hDC, ptDst.x, ptDst.y, sizeImg.cx, sizeImg.cy, hBmpDC, 0, 0, SRCCOPY);
// Cleanup
::SelectObject(hBmpDC, hOldBmp);
::DeleteDC(hBmpDC);
}
return(sizeImg);
} // END OF FUNCTION CTreeMenu::DrawImage()
CDropMenuDropTarget *CDropMenu::GetDropMenuDropTarget(CWnd *pOwner)
{
return new CDropMenuDropTarget(pOwner);
}
CSize CDropMenu::GetMenuSize(void)
{
CSize totalSize, itemSize;
int nColumnHeight = MENU_BORDER_SIZE, nColumnWidth = 0;
CalculateItemDimensions();
int nCount = m_pMenuItemArray.GetSize();
int nScreenLeft = 0;
int nScreenRight = GetSystemMetrics(SM_CXFULLSCREEN);
int nScreenTop = 0;
int nScreenBottom = GetSystemMetrics(SM_CYFULLSCREEN);
#ifdef XP_WIN32
RECT rect;
if(SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&rect,0))
{
nScreenLeft = rect.left;
nScreenRight = rect.right;
nScreenTop = rect.top;
nScreenBottom = rect.bottom;
}
#endif
int nStartX= MENU_BORDER_SIZE;
int nOldStartX = MENU_BORDER_SIZE;
int nMaxColumnHeight = 0;
int nNumColumns = m_pColumnArray.GetSize();
CSize columnSize;
CDropMenuColumn *pColumn;
m_nLastVisibleColumn = nNumColumns - 1;
for(int i = 0; i < nNumColumns; i++)
{
pColumn = (CDropMenuColumn *)m_pColumnArray[i];
if(pColumn->GetHasSubMenu())
pColumn->SetWidth(pColumn->GetWidth() + SUBMENU_LEFT_MARGIN + SUBMENU_RIGHT_MARGIN + SUBMENU_WIDTH);
else
pColumn->SetWidth(pColumn->GetWidth() + SUBMENU_RIGHT_MARGIN);
columnSize = CalculateColumn(pColumn, nStartX);
if(nScreenLeft + nStartX + columnSize.cx >= nScreenRight)
{
//if we have more than one column, don't put in the last separator
if(nNumColumns > 1)
{
if(m_pOverflowMenuItem != NULL)
{
if(i > 0)
nStartX = AddOverflowItem(i - 1, nOldStartX);
else
nStartX = AddOverflowItem(i, nStartX - SEPARATOR_WIDTH);
}
}
m_nLastVisibleColumn = i - 1;
break;
}
if(columnSize.cy > nMaxColumnHeight)
nMaxColumnHeight = columnSize.cy;
nOldStartX = nStartX;
nStartX += columnSize.cx;
if(i + 1 < nNumColumns)
nStartX += SEPARATOR_WIDTH;
}
totalSize.cy = nMaxColumnHeight;
totalSize.cx = ((nNumColumns > 1) ? nStartX - SEPARATOR_WIDTH : nStartX);
return totalSize;
}
CSize CDropMenu::CalculateColumn(CDropMenuColumn *pColumn, int nStartX)
{
int nStart = pColumn->GetFirstItem();
int nEnd = pColumn->GetLastItem();
int nColumnWidth = pColumn->GetWidth();
int nItemHeight;
CSize totalSize(0, MENU_BORDER_SIZE);
CSize itemSize;
for(int i = nStart; i <= nEnd; i++)
{
CDropMenuItem *item = (CDropMenuItem*)m_pMenuItemArray[i];
if(m_bShowFeedback)
totalSize.cy += SPACE_BETWEEN_ITEMS;
if(item->IsSeparator())
{
CRect rect (nStartX, totalSize.cy, nStartX + nColumnWidth, totalSize.cy + SEPARATOR_SPACE * 2 + SEPARATOR_HEIGHT);
item->SetMenuItemRect(rect);
nItemHeight = SEPARATOR_SPACE * 2 + SEPARATOR_HEIGHT;
}
else
{
itemSize=MeasureItem(item);
CRect rect(nStartX, totalSize.cy, nStartX + nColumnWidth, totalSize.cy + itemSize.cy);
item->SetMenuItemRect(rect);
nItemHeight = itemSize.cy;
}
totalSize.cy += nItemHeight;
}
return CSize(pColumn->GetWidth(), totalSize.cy);
}
//returns the x coordinate of the right side of this last column
int CDropMenu::AddOverflowItem(int nColumn, int nStartX)
{
int nScreenTop = 0;
int nScreenBottom = GetSystemMetrics(SM_CYFULLSCREEN);
#ifdef XP_WIN32
RECT rect;
if(SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&rect,0))
{
nScreenTop = rect.top;
nScreenBottom = rect.bottom;
}
#endif
CDropMenuColumn *pColumn = (CDropMenuColumn *)m_pColumnArray[nColumn];
int nPosition = pColumn->GetLastItem();
CDropMenuItem *pLastItem = (CDropMenuItem*)m_pMenuItemArray[nPosition];
if(pLastItem == m_pOverflowMenuItem)
return pColumn->GetWidth();
int nHeight = pColumn->GetHeight();
CRect overflowRect;
CRect itemRect;
CDropMenuItem *pItem;
CSize overflowSize = MeasureItem(m_pOverflowMenuItem);
overflowSize.cx += pColumn->GetWidestImage();
while(nScreenTop + nHeight + overflowSize.cy > nScreenBottom)
{
pItem = (CDropMenuItem*)m_pMenuItemArray[nPosition];
pItem->GetMenuItemRect(&itemRect);
nHeight -= itemRect.Height();
nPosition--;
}
// add 1 since we've subtracted 1 away
pColumn->SetLastItem(nPosition + 1);
pColumn->SetHeight(nHeight + overflowSize.cy);
m_pOverflowMenuItem->SetColumn(nColumn);
if(overflowSize.cx > pColumn->GetWidth())
pColumn->SetWidth(overflowSize.cx);
m_pMenuItemArray.InsertAt(nPosition + 1, m_pOverflowMenuItem, 1);
itemRect.SetRect(nStartX, nHeight, nStartX + pColumn->GetWidth(), nHeight + overflowSize.cy);
m_pOverflowMenuItem->SetMenuItemRect(itemRect);
return (nStartX + pColumn->GetWidth());
}
void CDropMenu::CalculateItemDimensions(void)
{
int numItems = m_pMenuItemArray.GetSize();
int nScreenTop = 0;
int nScreenBottom = GetSystemMetrics(SM_CYFULLSCREEN);
#ifdef XP_WIN32
RECT rect;
if(SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&rect,0))
{
nScreenTop = rect.top;
nScreenBottom = rect.bottom;
}
#endif
int nNumCols = 0;
int nColumnHeight = nScreenBottom + 1;
int nColumnWidth = 0;
CSize textSize, unselectedBitmapSize, selectedBitmapSize, itemSize;
CDropMenuColumn *pColumn = NULL;
int nMaxBitmapSize = 0, nMaxTextSize = 0;
int nCount = m_pColumnArray.GetSize();
//make sure column array is empty
for(int j = 0 ; j < nCount; j++)
delete (CDropMenuColumn*)m_pColumnArray[j];
m_pColumnArray.RemoveAll();
for(int i=0; i<numItems; i++)
{
CDropMenuItem *item = (CDropMenuItem*)m_pMenuItemArray[i];
CalculateOneItemsDimensions(item);
textSize = item->GetTextSize();
selectedBitmapSize = item->GetSelectedBitmapSize();
unselectedBitmapSize = item->GetUnselectedBitmapSize();
itemSize = MeasureItem(item);
if(nScreenTop + nColumnHeight + itemSize.cy > nScreenBottom)
{
pColumn = new CDropMenuColumn;
pColumn->SetHasSubMenu(FALSE);
pColumn->SetFirstItem(i);
m_pColumnArray.Add(pColumn);
nColumnHeight = nColumnWidth = 0;
nMaxBitmapSize = 0, nMaxTextSize = 0;
nNumCols++;
}
item->SetColumn(nNumCols - 1);
pColumn->SetLastItem(i);
if(unselectedBitmapSize.cx > nMaxBitmapSize)
nMaxBitmapSize = unselectedBitmapSize.cx;
if(selectedBitmapSize.cx > nMaxBitmapSize)
nMaxBitmapSize= selectedBitmapSize.cx;
if(textSize.cx > nMaxTextSize)
nMaxTextSize = textSize.cx;
if(item->IsSubMenu())
pColumn->SetHasSubMenu(TRUE);
nColumnHeight += itemSize.cy;
if(m_bShowFeedback)
nColumnHeight += SPACE_BETWEEN_ITEMS;
pColumn->SetHeight(nColumnHeight);
pColumn->SetWidth(nMaxBitmapSize + nMaxTextSize + ( nIMG_SPACE * 3));
pColumn->SetWidestImage(nMaxBitmapSize);
if(item == m_pOverflowMenuItem)
return;
}
if(m_pOverflowMenuItem != NULL)
CalculateOneItemsDimensions(m_pOverflowMenuItem);
}
void CDropMenu::CalculateOneItemsDimensions(CDropMenuItem* item)
{
CSize unselectedBitmapSize, selectedBitmapSize, textSize;
CString text;
if(!item->IsSeparator())
{
unselectedBitmapSize = MeasureBitmap(item->GetUnselectedBitmap());
item->SetUnselectedBitmapSize(unselectedBitmapSize);
selectedBitmapSize = MeasureBitmap(item->GetSelectedBitmap());
item->SetSelectedBitmapSize(selectedBitmapSize);
if(item->IsSubMenu())
{
m_bHasSubMenu = TRUE;
}
text = item->GetText();
textSize = MeasureText(text);
item->SetTextSize(textSize);
}
}
/****************************************************************************
*
* CTreeMenu::MeasureBitmap
*
* PARAMETERS:
* pBitmap: The bitmap to measure
*
* RETURNS:
* The size of the bitmap
*
* DESCRIPTION:
* Given a bitmap, this returns its dimensions
*
****************************************************************************/
CSize CDropMenu::MeasureBitmap(HBITMAP hBitmap)
{
CSize size;
if (hBitmap != NULL)
{
BITMAP bmp;
GetObject(hBitmap, sizeof(bmp), &bmp);
size.cx = bmp.bmWidth;
size.cy = bmp.bmHeight;
}
else
size.cx = size.cy = 0;
return size;
}
/****************************************************************************
*
* CTreeMenu::MeasureText
*
* PARAMETERS:
* text: The CString text to be measured
*
* RETURNS:
* Returns the size of the text in the current font
*
* DESCRIPTION:
* Given a CString this returns the dimensions of that text
*
****************************************************************************/
CSize CDropMenu::MeasureText(CString text)
{
HFONT hMenuFont;
#if defined(WIN32)
NONCLIENTMETRICS ncm;
ncm.cbSize = sizeof(NONCLIENTMETRICS);
if (::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0))
{
hMenuFont = theApp.CreateAppFont( ncm.lfMenuFont );
}
else
{
hMenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
}
#else // Win16
hMenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
#endif // WIN32
HDC hDC = ::GetDC(m_hWnd);
HFONT hOldFont = (HFONT) ::SelectObject(hDC, hMenuFont);
CSize sizeTxt = ::GetTabbedTextExtent(hDC, (LPCSTR)text, strlen(text), 0, NULL);
::SelectObject(hDC, hOldFont);
#if defined(WIN32)
if (::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0))
{
theApp.ReleaseAppFont(hMenuFont);
}
#endif
::ReleaseDC(m_hWnd, hDC);
return sizeTxt;
}
/****************************************************************************
*
* CTreeMenu::MeasureItem
*
* PARAMETERS:
* lpMI - pointer to LPMEASUREITEMSTRUCT
*
* RETURNS:
* void
*
* DESCRIPTION:
* We must override this function to inform the system of our menu
* item dimensions, since we're owner draw style.
*
****************************************************************************/
//menu item and end of accelerator
CSize CDropMenu::MeasureItem(CDropMenuItem *pItem)
{
ASSERT(pItem != NULL);
CSize size;
if(pItem->IsSeparator())
{
size.cx = 0;
size.cy = SEPARATOR_SPACE * 2 + SEPARATOR_HEIGHT;
}
else
{
// First, get all of the dimensions
CSize unselectedSizeImg=pItem->GetUnselectedBitmapSize();
CSize selectedSizeImg = pItem->GetSelectedBitmapSize();
CSize sizeText=pItem->GetTextSize();
size.cx = sizeText.cx + (nIMG_SPACE * 2);
int maxImageHeight = max(unselectedSizeImg.cy, selectedSizeImg.cy);
size.cy = max(maxImageHeight, sizeText.cy) + 4;
}
return size;
}
void CDropMenu::ChangeSelection(CPoint point)
{
if(m_bShowing)
{
MenuSelectionType eSelType;
int nSelection = FindSelection(point, eSelType);
eSelType = m_bShowFeedback ? eSelType : eNONE;
if(m_nSelectedItem != nSelection || m_eSelectedItemSelType != eSelType)
{
SelectMenuItem(m_nSelectedItem, FALSE, TRUE, m_eSelectedItemSelType);
SelectMenuItem(nSelection, TRUE, TRUE, eSelType);
}
}
}
int CDropMenu::FindSelection(CPoint point, MenuSelectionType &eSelType)
{
eSelType = eNONE;
int nNumColumns = m_pColumnArray.GetSize();
CRect colRect;
CDropMenuColumn *pColumn;
int nStartX = MENU_BORDER_SIZE;
int nColumnWidth;
for(int i = 0; i < nNumColumns; i++)
{
pColumn = (CDropMenuColumn*)m_pColumnArray[i];
nColumnWidth = pColumn->GetWidth();
colRect.SetRect(nStartX, 0, nStartX + nColumnWidth, pColumn->GetHeight());
if(colRect.PtInRect(point))
{
return (FindSelectionInColumn(pColumn, point, eSelType));
}
else
{
nStartX += nColumnWidth + SEPARATOR_WIDTH;
}
}
return -1;
}
int CDropMenu::FindSelectionInColumn(CDropMenuColumn *pColumn, CPoint point, MenuSelectionType &eSelType)
{
int y = MENU_BORDER_SIZE;
if(point.y >=0 && point.y <= MENU_BORDER_SIZE)
return 0;
int nFeedbackHeight = m_bShowFeedback ? SPACE_BETWEEN_ITEMS : 0;
CDropMenuItem *item;
int nFirstItem = pColumn->GetFirstItem();
int nLastItem = pColumn->GetLastItem();
for(int i = nFirstItem; i <= nLastItem; i++)
{
item = (CDropMenuItem*)m_pMenuItemArray[i];
CRect rect;
item->GetMenuItemRect(rect);
if( point.y >= y && point.y < y + rect.Height() + nFeedbackHeight)
{
if(item->GetShowFeedback())
eSelType = FindSelectionType(item, point.y - y, rect.Height() + nFeedbackHeight);
return i;
}
y += rect.Height() + nFeedbackHeight;
}
//if we're in the border between the bottom and the last menu item
if(point.y >= y && point.y <= y + 2*MENU_BORDER_SIZE)
{
if(item->GetShowFeedback())
eSelType = eBELOW;
return i - 1;
}
return -1;
}
MenuSelectionType CDropMenu::FindSelectionType(CDropMenuItem *pItem, int y, int nHeight)
{
if(pItem->IsSubMenu())
{
if (y >= 0 && y <= nHeight/4.0)
return eABOVE;
else if (y <= 3.0*nHeight/4.0)
return eON;
else return eBELOW;
}
else
{
if(y >= 0 && y <= nHeight / 2.0)
return eABOVE;
else
return eBELOW;
}
}
void CDropMenu::SelectMenuItem(int nItemIndex, BOOL bIsSelected, BOOL bHandleSubmenus, MenuSelectionType eSelType)
{
RECT rcClient;
GetClientRect(&rcClient);
if(nItemIndex != -1)
{
CDropMenuItem *item = (CDropMenuItem*)m_pMenuItemArray[nItemIndex];
InvalidateMenuItemRect(item);
if(!bIsSelected)
{
m_pShowingSubmenu = NULL;
m_nSelectedItem = -1;
m_eSelectedItemSelType = eNONE;
if(bHandleSubmenus && item->IsSubMenu() && !item->IsEmpty() && item->GetSubMenu()->m_bShowing)
{
if(m_pUnselectedItem == NULL)
{
item->GetSubMenu()->m_bShowing = FALSE;
m_pUnselectedItem = item;
m_nUnselectTimer = SetTimer(IDT_SUBMENU_OFF ,SUBMENU_DELAY_OFF_MS, NULL);
}
}
}
else
{
m_nSelectedItem = nItemIndex;
m_eSelectedItemSelType = eSelType;
if(m_nSelectTimer != 0)
{
KillTimer(m_nSelectTimer);
}
if(bHandleSubmenus && item->IsSubMenu() && !item->IsEmpty() && (eSelType == eON || eSelType == eNONE))
{
m_pShowingSubmenu = item->GetSubMenu();
m_pSelectedItem = item;
m_pSelectedItem->GetSubMenu()->m_bAboutToShow = TRUE;
m_nSelectTimer = SetTimer(IDT_SUBMENU_ON, SUBMENU_DELAY_ON_MS, NULL);
}
}
}
}
BOOL CDropMenu::NoSubmenusShowing(void)
{
CWnd *child = GetWindow(GW_CHILD);
if(child != NULL)
{
while(child != NULL)
{
if(child->IsWindowVisible())
{
return FALSE;
}
child = GetWindow(GW_HWNDNEXT);
}
}
return TRUE;
}
CDropMenu *CDropMenu::GetMenuParent(void)
{
return m_pMenuParent;
}
BOOL CDropMenu::IsDescendant(CWnd *pDescendant)
{
CDropMenu *pSubmenu = m_pShowingSubmenu;
while(pSubmenu != NULL)
{
if(pSubmenu == pDescendant)
{
return TRUE;
}
pSubmenu = pSubmenu->m_pShowingSubmenu;
}
return FALSE;
}
BOOL CDropMenu::IsAncestor(CWnd *pAncestor)
{
CDropMenu *pMenu = this;
while(pMenu->m_pParent == pMenu->m_pMenuParent)
{
if(pMenu->m_pMenuParent == pAncestor)
{
return TRUE;
}
pMenu = pMenu->m_pMenuParent;
}
return FALSE;
}
//Sees if the hwnd is either this menu, an ancestor or a submenu
BOOL CDropMenu::IsShowingMenu(HWND hwnd)
{
if(hwnd == m_hWnd)
{
return TRUE;
}
else
{
CDropMenu *menu = m_pMenuParent;
while(menu != NULL)
{
if(hwnd == menu->m_hWnd)
{
return TRUE;
}
menu=menu->m_pMenuParent;
}
menu = m_pShowingSubmenu;
while(menu !=NULL)
{
if(hwnd == menu->m_hWnd)
{
return TRUE;
}
menu = menu->m_pShowingSubmenu;
}
}
return FALSE;
}
void CDropMenu::DropMenuTrackDropMenu(CDropMenu *pParent, int x, int y, BOOL bDragging, CDropMenuDropTarget *pDropTarget,
BOOL bShowFeedback, int oppX, int oppY)
{
m_pMenuParent = pParent;
pParent->m_pShowingSubmenu = this;
TrackDropMenu(pParent, x, y, bDragging, pDropTarget, bShowFeedback, oppX, oppY);
}
int CDropMenu::FindCommand(UINT nCommand)
{
int nCount = m_pMenuItemArray.GetSize();
for(int i = 0; i < nCount; i++)
{
CDropMenuItem * pItem = (CDropMenuItem*)m_pMenuItemArray[i];
if(!pItem->IsSeparator())
{
if(pItem->GetCommand() == nCommand)
{
return i;
}
}
}
return -1;
}
CPoint CDropMenu::FindStartPoint(int x, int y, CSize size, int oppX, int oppY)
{
int nScreenLeft = 0;
int nScreenRight = GetSystemMetrics(SM_CXFULLSCREEN);
int nScreenTop = 0;
int nScreenBottom = GetSystemMetrics(SM_CYFULLSCREEN);
#ifdef XP_WIN32
RECT rect;
if(SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&rect,0))
{
nScreenLeft = rect.left;
nScreenRight = rect.right;
nScreenTop = rect.top;
nScreenBottom = rect.bottom;
}
#endif
if(oppX == -1)
{
CRect parentRect;
m_pParent->GetWindowRect(&parentRect);
oppX = m_bRight ? parentRect.left : parentRect.right;
}
int nRoomToRight = nScreenRight - (m_bRight ? x : oppX);
int nRoomToLeft = (m_bRight ? oppX : x) - nScreenLeft;
// if we are opening to the right we need to make sure we don't go off the right
// side of the screen.
if(m_bRight)
{
//if we will extend past the right
if(x + size.cx > nScreenRight)
{
// if we can fit to the left
if(oppX - size.cx > nScreenLeft)
{
if(m_pMenuParent != NULL)
{
x = oppX - size.cx;
//if it's not the top level menu we want it to overlap its parent
x -= 2;
}
else
{
x = oppX - size.cx;
}
m_bRight = FALSE;
}
else
{
//see where we have more space
if(nRoomToRight >= nRoomToLeft)
x = nScreenRight - size.cx;
else
{
x = nScreenLeft;
m_bRight = FALSE;
}
}
}
else if(m_pMenuParent != NULL)
{
// if we are a submenu we want to overlap our parent
x -= 5;
}
}
// if we are opening to the left we need to make sure we don't go off the left
// side of the screen
else
{
//if we will extend past the left
if(x - size.cx < nScreenLeft)
{
// if we can fit to the right
if(oppX + size.cx < nScreenRight)
{
x = oppX;
//if it's not the top level menu we want it to overlap its parent
if(m_pMenuParent != NULL)
{
x -= 5;
}
m_bRight = TRUE;
}
else
{
if(nRoomToRight >= nRoomToLeft)
{
x = nScreenRight - size.cx;
m_bRight = TRUE;
}
else
x = nScreenLeft;
}
}
else if(m_pMenuParent != NULL)
{
x -= size.cx;
// if we are a submenu we want to overlap our parent
x -= 2;
}
}
if(y + size.cy > nScreenBottom)
{
y -= ((y + size.cy) - nScreenBottom);
}
return CPoint(x, y);
}
void CDropMenu::HandleUpArrow(void)
{
int nSelection;
// need to deal with separators
if(m_nSelectedItem == NOSELECTION || m_nSelectedItem == 0)
{
nSelection = GetMenuItemCount() - 1;
}
else
{
nSelection = m_nSelectedItem - 1;
}
while(((CDropMenuItem *)m_pMenuItemArray[nSelection])->IsSeparator())
{
nSelection = (nSelection == 0) ? GetMenuItemCount() - 1 : nSelection - 1;
}
SelectMenuItem(m_nSelectedItem, FALSE, FALSE, eNONE);
SelectMenuItem(nSelection, TRUE, FALSE, eNONE);
}
void CDropMenu::HandleDownArrow(void)
{
int nSelection;
int nNumItems = GetMenuItemCount() - 1;
// need to deal with separators
if(m_nSelectedItem == NOSELECTION || m_nSelectedItem == nNumItems)
{
nSelection = 0;
}
else
{
nSelection = m_nSelectedItem + 1;
}
while(((CDropMenuItem *)m_pMenuItemArray[nSelection])->IsSeparator())
{
nSelection = (nSelection == nNumItems - 1) ? 0 : nSelection + 1;
}
SelectMenuItem(m_nSelectedItem, FALSE, FALSE, eNONE);
SelectMenuItem(nSelection, TRUE, FALSE, eNONE);
}
void CDropMenu::HandleLeftArrow(void)
{
if(m_pMenuParent != NULL)
{
m_bShowing = FALSE;
m_pMenuParent->m_bMouseUsed = FALSE;
ShowWindow(SW_HIDE);
}
}
void CDropMenu::HandleRightArrow(void)
{
if(m_nSelectedItem != NOSELECTION)
{
CDropMenuItem *pItem = (CDropMenuItem *)m_pMenuItemArray[m_nSelectedItem];
if(pItem->IsSubMenu())
{
m_pShowingSubmenu = pItem->GetSubMenu();
m_pShowingSubmenu->m_nSelectedItem = 0;
m_pShowingSubmenu->m_bMouseUsed = FALSE;
ShowSubmenu(pItem);
}
}
}
void CDropMenu::HandleReturnKey(void)
{
if(m_nSelectedItem != NOSELECTION)
{
CDropMenuItem *pItem = (CDropMenuItem *)m_pMenuItemArray[m_nSelectedItem];
if(pItem->IsSubMenu())
{
HandleRightArrow();
}
else
{
#ifdef _WIN32
SendMessage(WM_COMMAND, MAKEWPARAM(pItem->GetCommand(), 0), 0);
#else
SendMessage(WM_COMMAND, (WPARAM) pItem->GetCommand(), MAKELPARAM( m_hWnd, 0 ));
#endif
}
}
}
void CDropMenu::ShowSubmenu(CDropMenuItem *pItem)
{
CRect rcClient, rect;
GetClientRect(rcClient);
pItem->GetMenuItemRect(rect);
CDropMenuDropTarget *pDropTarget = GetDropMenuDropTarget(pItem->GetSubMenu());
ClientToScreen(rect);
m_pShowingSubmenu = pItem->GetSubMenu();
pItem->GetSubMenu()->SetSubmenuBitmaps(m_hSubmenuSelectedBitmap, m_hSubmenuUnselectedBitmap);
if(m_bRight)
{
pItem->GetSubMenu()->DropMenuTrackDropMenu(this, rect.right, rect.top - 2, m_bDragging, pDropTarget, m_bShowFeedback, rect.left);
}
else
{
pItem->GetSubMenu()->DropMenuTrackDropMenu(this, rect.left, rect.top - 2, m_bDragging, pDropTarget, m_bShowFeedback, rect.right);
}
pItem->GetSubMenu()->m_pParentMenuItem = pItem;
}
int CDropMenu::FindMenuItemPosition(CDropMenuItem* pMenuItem)
{
int nCount = m_pMenuItemArray.GetSize();
for(int i = 0; i < nCount; i++)
if(m_pMenuItemArray[i] == pMenuItem)
return i;
return -1;
}
void CDropMenu::SetSubmenuBitmaps(HBITMAP hSelectedBitmap, HBITMAP hUnselectedBitmap)
{
m_hSubmenuUnselectedBitmap = hUnselectedBitmap;
m_hSubmenuSelectedBitmap = hSelectedBitmap;
}
void CDropMenu::InvalidateMenuItemRect(CDropMenuItem *pMenuItem)
{
CRect rcClient;
CRect rect;
GetClientRect(&rcClient);
pMenuItem->GetMenuItemRect(rect);
int nColumn = pMenuItem->GetColumn();
CDropMenuColumn *pColumn= (CDropMenuColumn*)m_pColumnArray[nColumn];
rect.right = rect.left + pColumn->GetWidth();
rect.top -= 2;
rect.bottom += 2;
InvalidateRect(rect, TRUE);
}
void CDropMenu::InvalidateMenuItemIconRect(CDropMenuItem *pMenuItem)
{
CRect rcClient;
CRect rect;
GetClientRect(&rcClient);
pMenuItem->GetMenuItemRect(rect);
int nColumn = pMenuItem->GetColumn();
CDropMenuColumn *pColumn= (CDropMenuColumn*)m_pColumnArray[nColumn];
rect.left += nIMG_SPACE;
rect.right = rect.left + 16;
InvalidateRect(rect, TRUE);
}
void CDropMenu::KeepMenuAroundIfClosing(void)
{
// if there is movement on this menu, then it is showing even
// if it's been told to go away before.
m_bShowing = TRUE;
if(m_pMenuParent)
{
CDropMenuItem *pSelectedItem = m_pMenuParent->m_nSelectedItem != -1 ? (CDropMenuItem*)m_pMenuParent->m_pMenuItemArray[m_pMenuParent->m_nSelectedItem] : NULL;
CDropMenu *pSubMenu = pSelectedItem && pSelectedItem->IsSubMenu() ? pSelectedItem->GetSubMenu() : NULL;
if((pSubMenu && pSubMenu != this) || !pSubMenu)
{
KillTimer(m_pMenuParent->m_nSelectTimer);
KillTimer(m_pMenuParent->m_nUnselectTimer);
m_pMenuParent->m_pUnselectedItem = NULL;
m_pMenuParent->m_nSelectTimer = 0;
m_pMenuParent->m_pShowingSubmenu = this;
//We need to make the menu item this belongs to the selected menu item.
int nPosition = m_pMenuParent->FindMenuItemPosition(m_pParentMenuItem);
if(nPosition != -1)
{
if(pSelectedItem)
{
m_pMenuParent->InvalidateMenuItemRect(pSelectedItem);
}
m_pMenuParent->m_nSelectedItem = nPosition;
m_pMenuParent->m_eSelectedItemSelType = eON;
m_pMenuParent->m_pSelectedItem = m_pParentMenuItem;
m_pMenuParent->InvalidateMenuItemRect(m_pParentMenuItem);
}
}
}
}
CWnd *CDropMenu::GetTopLevelParent(void)
{
CDropMenu *pMenu = this;
while(pMenu->m_pMenuParent != NULL)
{
pMenu = pMenu->m_pMenuParent;
}
return pMenu->m_pParent;
}
void CDropMenu::LoadComplete(HT_Resource r)
{
// Need to invalidate the line that corresponds to this particular resource.
HT_Resource parent = HT_GetParent(r);
if (parent)
{
// The offset of this node from its direct parent determines the line that should be
// invalidated.
int childIndex = HT_GetNodeIndex(HT_GetView(r), r);
int parentIndex = HT_GetNodeIndex(HT_GetView(parent), parent);
if (parent == HT_TopNode(HT_GetView(r)))
parentIndex = -1;
// Need to count up from the parent index to the child index and only include nodes
// with indentation equal to the child index.
int indentation = HT_GetItemIndentation(r);
int offset = 0;
for (int i = parentIndex + 1; i < childIndex; i++)
{
int otherIndentation = HT_GetItemIndentation(HT_GetNthItem(HT_GetView(r), i));
if (otherIndentation == indentation)
offset++;
}
CDropMenuItem *item = (CDropMenuItem*)m_pMenuItemArray[offset];
InvalidateMenuItemIconRect(item);
}
}
Reference in New Issue View Git Blame Copy Permalink