Windows/UltimateToolbox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
UltimateToolbox/UltimateToolbox93_src/Ultimate Toolbox/source/OXBitmapMenu.cpp
Raten fb064541d6 new
2025-11-27 16:46:48 +09:00

2183 lines
54 KiB
C++
Raw Permalink Blame History

// ==========================================================================
// Class Implementation : COXBitmapMenu
// ==========================================================================
// Source file : OXBitmapMenu.cpp
// Version: 9.3
// This software along with its related components, documentation and files ("The Libraries")
// is © 1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
// governed by a software license agreement ("Agreement"). Copies of the Agreement are
// available at The Code Project (www.codeproject.com), as part of the package you downloaded
// to obtain this file, or directly from our office. For a copy of the license governing
// this software, you may contact us at legalaffairs@codeproject.com, or by calling 416-849-8900.
// //////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#pragma warning(disable : 4706)
#include <multimon.h>
#include "OXBitmapMenu.h"
#include "OXBitmapMenuOrganizer.h"
#include "OXSkins.h"
#include "OXCoolToolBar.h"
#include "OXMenuBar.h"
#ifdef OX_CUSTOMIZE_COMMANDS
#include "OXDragDropCommands.h"
#endif // OX_CUSTOMIZE_COMMANDS
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#endif
/////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(COXBitmapMenuPopupWnd,CWnd)
COXBitmapMenuPopupWnd::COXBitmapMenuPopupWnd() :
m_pBitmapMenu(NULL),
m_nCheckForDragDropEventTimerID(0)
{
}
COXBitmapMenuPopupWnd::~COXBitmapMenuPopupWnd()
{
ResetPopupMenu();
}
BEGIN_MESSAGE_MAP(COXBitmapMenuPopupWnd,CWnd)
//{{AFX_MSG_MAP(COXBitmapMenuPopupWnd)
ON_WM_RBUTTONUP()
ON_WM_LBUTTONDOWN()
ON_WM_MBUTTONDOWN()
ON_WM_RBUTTONDOWN()
ON_WM_PAINT()
ON_WM_MOUSEACTIVATE()
ON_WM_SETTINGCHANGE()
ON_WM_TIMER()
ON_WM_MOUSEMOVE()
ON_WM_NCPAINT()
//}}AFX_MSG_MAP
// handle drag'n'drop messages
ON_MESSAGE(SHBDTM_DRAGENTER, OnDragEnter)
ON_MESSAGE(SHBDTM_DRAGLEAVE, OnDragLeave)
ON_MESSAGE(SHBDTM_DRAGOVER, OnDragOver)
ON_MESSAGE(SHBDTM_DROP, OnDrop)
// handle advanced customization commands
ON_COMMAND(ID_OXCUSTBM_DELETE,OnCustBMDelete)
ON_COMMAND(ID_OXCUSTBM_APPEARANCE,OnCustBMAppearance)
ON_COMMAND(ID_OXCUSTBM_SEPARATOR_BEFORE,OnCustBMSeparatorBefore)
ON_COMMAND(ID_OXCUSTBM_SEPARATOR_AFTER,OnCustBMSeparatorAfter)
ON_COMMAND(ID_OXCUSTBM_RECENTLY_USED,OnCustBMRecentlyUsed)
END_MESSAGE_MAP()
void COXBitmapMenuPopupWnd::OnLButtonDown(UINT nFlags, CPoint point)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(m_nCheckForDragDropEventTimerID==0 &&
pMenu!=NULL && pMenu->IsInCustomizationMode())
{
int nItemIndex=pMenu->HitTest(&point);
if(nItemIndex>=0 && nItemIndex<(int)pMenu->GetMenuItemCount())
{
pMenu->SetCustomizedItem(nItemIndex);
}
else
{
pMenu->SetCustomizedItem(-1);
}
m_nCheckForDragDropEventTimerID=SetTimer(IDT_OXCHECKFORDRAGDROPEVENT,
ID_OXCHECKFORDRAGDROPEVENT_DELAY,NULL);
ASSERT(m_nCheckForDragDropEventTimerID!=0);
return;
}
CWnd::OnLButtonDown(nFlags,point);
}
void COXBitmapMenuPopupWnd::OnMButtonDown(UINT nFlags, CPoint point)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
int nItemIndex=pMenu->HitTest(&point);
if(nItemIndex>=0 && nItemIndex<(int)pMenu->GetMenuItemCount())
{
pMenu->SetCustomizedItem(nItemIndex);
}
else
{
pMenu->SetCustomizedItem(-1);
}
return;
}
CWnd::OnMButtonDown(nFlags,point);
}
void COXBitmapMenuPopupWnd::OnRButtonDown(UINT nFlags, CPoint point)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
int nItemIndex=pMenu->HitTest(&point);
if(nItemIndex>=0 && nItemIndex<(int)pMenu->GetMenuItemCount())
{
pMenu->SetCustomizedItem(nItemIndex);
}
else
{
pMenu->SetCustomizedItem(-1);
}
return;
}
CWnd::OnRButtonDown(nFlags,point);
}
void COXBitmapMenuPopupWnd::OnRButtonUp(UINT nFlags, CPoint point)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
int nCustomizedItemIndex=pMenu->GetCustomizedItem();
if(nCustomizedItemIndex!=-1)
{
ClientToScreen(&point);
pMenu->DisplayCustomizeItemContextMenu(nCustomizedItemIndex,point);
return;
}
}
CWnd::OnRButtonUp(nFlags,point);
}
void COXBitmapMenuPopupWnd::OnMouseMove(UINT nFlags, CPoint point)
{
if(m_nCheckForDragDropEventTimerID!=0 && ::GetKeyState(VK_LBUTTON)>=0)
{
KillTimer(m_nCheckForDragDropEventTimerID);
m_nCheckForDragDropEventTimerID=0;
}
CWnd::OnMouseMove(nFlags,point);
}
LONG COXBitmapMenuPopupWnd::OnDragEnter(WPARAM wParam, LPARAM lParam)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
// lParam is the pointer to SHBDROPTARGETACTION structure
LPSHBDROPTARGETACTION pSHBDTAction=(LPSHBDROPTARGETACTION)lParam;
ASSERT(pSHBDTAction!=NULL);
ASSERT(pSHBDTAction->pWnd);
ASSERT(pSHBDTAction->pWnd->GetSafeHwnd()==GetSafeHwnd());
return pMenu->OnDragOver(wParam,lParam);
}
return (LONG)FALSE;
}
LONG COXBitmapMenuPopupWnd::OnDragOver(WPARAM wParam, LPARAM lParam)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
// lParam is the pointer to SHBDROPTARGETACTION structure
LPSHBDROPTARGETACTION pSHBDTAction=(LPSHBDROPTARGETACTION)lParam;
ASSERT(pSHBDTAction!=NULL);
ASSERT(pSHBDTAction->pWnd);
ASSERT(pSHBDTAction->pWnd->GetSafeHwnd()==GetSafeHwnd());
return pMenu->OnDragOver(wParam,lParam);
}
return (LONG)FALSE;
}
LONG COXBitmapMenuPopupWnd::OnDragLeave(WPARAM wParam, LPARAM lParam)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
// lParam is the pointer to SHBDROPTARGETACTION structure
LPSHBDROPTARGETACTION pSHBDTAction=(LPSHBDROPTARGETACTION)lParam;
ASSERT(pSHBDTAction!=NULL);
ASSERT(pSHBDTAction->pWnd);
ASSERT(pSHBDTAction->pWnd->GetSafeHwnd()==GetSafeHwnd());
return pMenu->OnDragLeave(wParam,lParam);
}
return (LONG)FALSE;
}
LONG COXBitmapMenuPopupWnd::OnDrop(WPARAM wParam, LPARAM lParam)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
// lParam is the pointer to SHBDROPTARGETACTION structure
LPSHBDROPTARGETACTION pSHBDTAction=(LPSHBDROPTARGETACTION)lParam;
ASSERT(pSHBDTAction!=NULL);
ASSERT(pSHBDTAction->pWnd);
ASSERT(pSHBDTAction->pWnd->GetSafeHwnd()==GetSafeHwnd());
return pMenu->OnDrop(wParam,lParam);
}
return (LONG)FALSE;
}
void COXBitmapMenuPopupWnd::OnCustBMDelete()
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
pMenu->OnCustBMDelete();
}
}
void COXBitmapMenuPopupWnd::OnCustBMAppearance()
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
pMenu->OnCustBMAppearance();
}
}
void COXBitmapMenuPopupWnd::OnCustBMSeparatorBefore()
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
pMenu->OnCustBMSeparatorBefore();
}
}
void COXBitmapMenuPopupWnd::OnCustBMSeparatorAfter()
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
pMenu->OnCustBMSeparatorAfter();
}
}
void COXBitmapMenuPopupWnd::OnCustBMRecentlyUsed()
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
pMenu->OnCustBMRecentlyUsed();
}
}
void COXBitmapMenuPopupWnd::OnPaint()
{
CPaintDC dc(this);
int nSavedDC=dc.SaveDC();
ASSERT(nSavedDC!=0);
dc.SetTextColor(::GetSysColor(COLOR_MENUTEXT));
dc.SelectObject(&m_fontMenu);
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL)
{
ASSERT((int)pMenu->GetMenuItemCount()==m_arrItemRects.GetSize());
MENUITEMINFO mii={ sizeof(mii) };
mii.fMask=MIIM_DATA;
DRAWITEMSTRUCT dis;
dis.CtlType=ODT_MENU;
dis.hDC=dc.GetSafeHdc();
dis.itemAction=ODA_DRAWENTIRE;
dis.CtlID=0;
dis.itemState=0;
dis.hwndItem=(HWND)pMenu->GetSafeHmenu();
for(int nIndex=0; nIndex<m_arrItemRects.GetSize(); nIndex++)
{
dis.itemID=pMenu->GetMenuItemID(nIndex);
dis.rcItem=m_arrItemRects[nIndex];
VERIFY(::GetMenuItemInfo(pMenu->GetSafeHmenu(),nIndex,TRUE,&mii));
dis.itemData=mii.dwItemData;
pMenu->DrawItem(&dis);
}
}
VERIFY(dc.RestoreDC(nSavedDC));
}
int COXBitmapMenuPopupWnd::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest,
UINT message)
{
UNREFERENCED_PARAMETER(pDesktopWnd);
UNREFERENCED_PARAMETER(nHitTest);
UNREFERENCED_PARAMETER(message);
return MA_NOACTIVATE;
}
void COXBitmapMenuPopupWnd::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
{
UpdateMenuMetrics();
OnMenuChanged();
CWnd::OnSettingChange(uFlags, lpszSection);
}
void COXBitmapMenuPopupWnd::OnTimer(UINT nIDEvent)
{
if((int)nIDEvent==m_nCheckForDragDropEventTimerID)
{
KillTimer(m_nCheckForDragDropEventTimerID);
m_nCheckForDragDropEventTimerID=0;
if(::IsWindow(GetSafeHwnd()))
{
// do drag and drop
//
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL && pMenu->IsInCustomizationMode())
{
if(::GetKeyState(VK_LBUTTON)<0)
{
pMenu->OnBeginDragDrop(pMenu->GetCustomizedItem());
}
}
//
////////////////////////////////////
}
return;
}
CWnd::OnTimer(nIDEvent);
}
BOOL COXBitmapMenuPopupWnd::TrackPopupMenu(COXBitmapMenu* pMenu, UINT nFlags,
int x, int y, CWnd* pWnd)
{
ASSERT(pMenu!=NULL);
m_pBitmapMenu=pMenu;
COXBitmapMenu* pBitmapMenu=GetBitmapMenu();
pBitmapMenu->SetPopupWnd(this);
if(!::IsWindow(GetSafeHwnd()))
{
if(!CreateEx(WS_EX_DLGMODALFRAME,AfxRegisterWndClass(
CS_SAVEBITS|CS_DBLCLKS,0,(HBRUSH)(COLOR_BTNFACE+1),0),_T(""),
WS_POPUP,m_rectWindow,pWnd,0,NULL))
{
return FALSE;
}
}
// register OLE Drag'n'Drop
COleDropTarget* pOleDropTarget=pBitmapMenu->GetDropTarget();
ASSERT(pOleDropTarget!=NULL);
pOleDropTarget->Revoke();
if(!pOleDropTarget->Register(this))
{
TRACE(_T("COXBitmapMenuPopupWnd::Create: failed to register the control with COleDropTarget. You've probably forgotten to initialize OLE libraries using AfxOleInit function\n"));
}
pBitmapMenu->SetCutomizationMode(TRUE,pWnd->GetSafeHwnd());
// update info about the font used to display the menu
UpdateMenuMetrics();
// calculate the rectangles for the menu items and for the popup menu itself
VERIFY(CalcLayout(nFlags,x,y));
SetWindowPos(&wndTop,m_rectWindow.left,m_rectWindow.top,m_rectWindow.Width(),
m_rectWindow.Height(),SWP_NOACTIVATE|SWP_SHOWWINDOW);
ShowWindow(SW_SHOWNA);
return TRUE;
}
void COXBitmapMenuPopupWnd::ResetPopupMenu()
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu!=NULL)
{
if(!pMenu->IsDragDropOwner())
{
pMenu->SetCustomizedItem(-1);
pMenu->SetPopupWnd(NULL);
m_pBitmapMenu=NULL;
}
}
if(::IsWindow(GetSafeHwnd()))
{
ShowWindow(SW_HIDE);
}
}
BOOL COXBitmapMenuPopupWnd::CalcLayout(UINT nFlags, int x, int y)
{
COXBitmapMenu* pMenu=GetBitmapMenu();
if(pMenu==NULL)
{
return FALSE;
}
m_arrItemRects.RemoveAll();
m_rectWindow.SetRectEmpty();
int nWidth=0;
int nHeight=0;
int nIndex=0;
for(nIndex=0; nIndex<(int)pMenu->GetMenuItemCount(); nIndex++)
{
MENUITEMINFO mii={ sizeof(mii) };
mii.fMask=MIIM_DATA;
VERIFY(::GetMenuItemInfo(pMenu->GetSafeHmenu(),nIndex,TRUE,&mii));
MEASUREITEMSTRUCT mis;
mis.CtlType=ODT_MENU;
mis.itemData=mii.dwItemData;
mis.itemID=pMenu->GetMenuItemID(nIndex);
mis.itemHeight=0;
mis.itemWidth=0;
pMenu->MeasureItem(&mis);
CRect rect(0,nHeight,mis.itemWidth,nHeight+mis.itemHeight);
m_arrItemRects.Add(rect);
nHeight+=mis.itemHeight;
if(nWidth<(int)mis.itemWidth)
nWidth=mis.itemWidth;
}
if(nWidth==0 && nHeight==0)
{
nWidth=ID_OXBITMAPMENUPOPUPWND_DEFAULT_WIDTH;
nHeight=ID_OXBITMAPMENUPOPUPWND_DEFAULT_HEIGHT;
}
m_rectWindow.top=y;
switch(nFlags)
{
case TPM_CENTERALIGN:
m_rectWindow.left=x-nWidth/2;
break;
case TPM_LEFTALIGN:
m_rectWindow.left=x;
break;
case TPM_RIGHTALIGN:
m_rectWindow.left=x-nWidth;
break;
}
m_rectWindow.right=m_rectWindow.left+nWidth;
m_rectWindow.bottom=m_rectWindow.top+nHeight;
CRect rectCopy=m_rectWindow;
CalcWindowRect(m_rectWindow);
CSize szOffset(rectCopy.left-m_rectWindow.left,rectCopy.top-m_rectWindow.top);
m_rectWindow.OffsetRect(szOffset.cx,szOffset.cy);
m_rectWindow.InflateRect(0,0,2*szOffset.cx,0);
nWidth+=2*szOffset.cx;
// adjust rectangles for items
for(nIndex=0; nIndex<m_arrItemRects.GetSize(); nIndex++)
{
CRect& rect=m_arrItemRects[nIndex];
if(rect.Width()<nWidth)
rect.right=rect.left+nWidth;
}
return TRUE;
}
void COXBitmapMenuPopupWnd::UpdateMenuMetrics()
{
if((HFONT)m_fontMenu!=NULL)
m_fontMenu.DeleteObject();
// Menu font, height and color
NONCLIENTMETRICS ncm={ sizeof(ncm) };
SystemParametersInfo(SPI_GETNONCLIENTMETRICS,sizeof(ncm),&ncm,0);
VERIFY(m_fontMenu.CreateFontIndirect(&ncm.lfMenuFont));
}
void COXBitmapMenuPopupWnd::OnMenuChanged()
{
ASSERT(GetBitmapMenu()!=NULL);
ASSERT(::IsWindow(GetSafeHwnd()));
CRect rect;
GetWindowRect(rect);
CPoint ptStart=rect.TopLeft();
GetBitmapMenu()->CalcExtents();
VERIFY(CalcLayout(TPM_LEFTALIGN,ptStart.x,ptStart.y));
if(IsWindowVisible())
{
SetWindowPos(&wndTop,m_rectWindow.left,m_rectWindow.top,m_rectWindow.Width(),
m_rectWindow.Height(),SWP_NOACTIVATE|SWP_SHOWWINDOW);
RedrawWindow();
}
else
{
ResetPopupMenu();
}
}
void COXBitmapMenuPopupWnd::RedrawItem(int nIndex)
{
ASSERT(GetBitmapMenu()!=NULL);
ASSERT(::IsWindow(GetSafeHwnd()));
ASSERT(nIndex>=0 && nIndex<m_arrItemRects.GetSize());
CRect rect;
rect=m_arrItemRects[nIndex];
RedrawWindow(rect);
}
///////////////////////////////////////////////////////
// COXShadowedItemWnd
COXShadowedItemWnd::COXShadowedItemWnd(COXCoolToolBar* pCoolToolbar, int iMenuItem, UINT nPosFlags)
{
m_pCoolToolbar = pCoolToolbar;
m_iMenuItem = iMenuItem;
m_nPosFlags = nPosFlags;
}
COXShadowedItemWnd::~COXShadowedItemWnd()
{
}
BEGIN_MESSAGE_MAP(COXShadowedItemWnd, CWnd)
//{{AFX_MSG_MAP(COXShadowedItemWnd)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
WNDPROC COXBitmapMenu::m_origWndProc = NULL;
IMPLEMENT_DYNAMIC(COXBitmapMenu, CMenu)
COXMenuSkin* COXBitmapMenu::m_pMenuSkin = NULL;
COXBitmapMenu::COXBitmapMenu()
:
m_nBitmapExtent(0),
m_nTextHeight(0),
m_nAcceleratorExtent(0),
m_nStringExtent(0),
m_nCustomizedItemIndex(-1),
m_bCutomizable(FALSE),
m_bInCutomizationMode(FALSE),
m_bDragDropOwner(FALSE),
m_bDragDropOperation(FALSE),
m_hWndCustomizeOrganizer(NULL),
m_nInsertMarkIndex(-1),
m_pPopupWnd(NULL),
m_rectDropDownItem(0, 0, 0, 0)
{
// Sublass the menus
RegisterWindowClass(AfxGetInstanceHandle());
}
COXBitmapMenu::~COXBitmapMenu()
{
m_KeyAccessMap.RemoveAll();
COXItemInfo* pItemInfo;
while(!m_ItemInfoList.IsEmpty())
{
pItemInfo=m_ItemInfoList.RemoveHead();
delete pItemInfo;
pItemInfo = NULL;
}
TRACE(_T("\n"));
// delete the classic skin
if (m_pMenuSkin != NULL)
{
delete m_pMenuSkin;
m_pMenuSkin = NULL;
}
COleDropTarget* pOleDropTarget=GetDropTarget();
ASSERT(pOleDropTarget!=NULL);
pOleDropTarget->Revoke();
}
void COXBitmapMenu::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
ASSERT(m_hMenu!=NULL);
ASSERT(lpDrawItemStruct != NULL);
ASSERT(lpDrawItemStruct->CtlType == ODT_MENU);
UINT nState=lpDrawItemStruct->itemState;
CRect itemRect(lpDrawItemStruct->rcItem);
CRect buttonRect(0,0,0,0);
CRect imageRect(0,0,0,0);
CRect text1Rect(0,0,0,0);
CRect text2Rect(0,0,0,0);
CDC dc;
dc.Attach(lpDrawItemStruct->hDC);
COXItemInfo* pItemInfo=(COXItemInfo*)lpDrawItemStruct->itemData;
ASSERT(AfxIsValidAddress(pItemInfo, sizeof(COXItemInfo)));
COXImageInfo* pImageInfo=pItemInfo->GetImageInfo();
CString sText=pItemInfo->GetText();
if(lpDrawItemStruct->itemID!=0 && lpDrawItemStruct->itemID!=0xffff)
{
// Compute the space for each menu item part
DistributeSpace(
nState,pImageInfo,itemRect,buttonRect,imageRect,text1Rect,text2Rect);
}
COXBitmapMenuOrganizer* pOrganizer=
COXBitmapMenuOrganizer::FindOrganizer(AfxGetMainWnd()->GetSafeHwnd());
ASSERT(pOrganizer!=NULL);
BOOL bBefore=TRUE;
CPoint ptTest=itemRect.CenterPoint();
int nItemIndex=HitTest(&ptTest,&bBefore);
if(pOrganizer->IsShowOnlyRecentlyUsedItems() &&
!pOrganizer->IsRecentlyUsed(this,nItemIndex))
{
nState|=OXODS_HIDDEN;
if(nItemIndex>0 && pOrganizer->IsRecentlyUsed(this,nItemIndex-1))
{
nState|=OXODS_HIDDENFIRST;
}
if(nItemIndex<(int)GetMenuItemCount()-1 &&
pOrganizer->IsRecentlyUsed(this,nItemIndex+1))
{
nState|=OXODS_HIDDENLAST;
}
}
// Draw every part of the menu item
if(lpDrawItemStruct->itemID==0 || lpDrawItemStruct->itemID==0xffff)
{
DrawSeparator(&dc,itemRect);
}
else if(IsPopupItem(lpDrawItemStruct->itemID))
{
DrawSubmenuItem(&dc,nState,sText,pImageInfo,
itemRect,buttonRect,text1Rect,text2Rect);
}
else
{
DrawBackground(&dc,nState,pImageInfo,itemRect,buttonRect);
DrawButton(&dc,nState,pImageInfo,buttonRect);
DrawImage(&dc,nState,pImageInfo,imageRect);
if((((int)lpDrawItemStruct->itemID)&0x0000ffff)==ID_OX_SHOWALLITEMS)
{
ASSERT(!IsInCustomizationMode());
DrawExpansionItem(&dc,itemRect,nState);
}
else
{
DrawText(&dc,nState,sText,text1Rect,text2Rect);
}
}
// draw customized item
int nCustomizedItem=GetCustomizedItem();
if(nCustomizedItem!=-1 &&
GetMenuItemID(nCustomizedItem)==lpDrawItemStruct->itemID)
{
CPoint pt=itemRect.CenterPoint();
if(HitTest(&pt)==nCustomizedItem)
{
DrawCustomized(&dc,itemRect);
}
}
// draw insert mark
int nInsertMark=GetInsertMark();
if(nInsertMark!=-1)
{
ASSERT(nInsertMark>=0 && nInsertMark<=(int)GetMenuItemCount());
BOOL bBefore=(nInsertMark<(int)GetMenuItemCount());
if(!bBefore)
nInsertMark--;
CPoint pt=itemRect.CenterPoint();
if(HitTest(&pt)==nInsertMark)
{
DrawInsertMark(&dc,itemRect,bBefore);
}
}
dc.Detach();
}
void COXBitmapMenu::DistributeSpace(UINT nState,
COXImageInfo* pImageInfo,
CRect itemRect,
CRect& buttonRect,
CRect& imageRect,
CRect& text1Rect,
CRect& text2Rect)
{
GetMenuSkin()->DistributeSpace(nState, pImageInfo, itemRect, buttonRect, imageRect,
text1Rect, text2Rect, this);
}
HBRUSH COXBitmapMenu::HBrushDitherCreate(COLORREF rgbFace, COLORREF rgbHilight)
{
struct //BITMAPINFO with 16 colors
{
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[16];
} bmi;
HBRUSH hBrush=NULL;
DWORD patGray[8];
HDC hDC;
HBITMAP hBmp;
static COLORREF rgbFaceOld=0xFFFFFFFF; //Initially impossible
static COLORREF rgbHilightOld=0xFFFFFFFF; //Initially impossible
/*
* We're going to create an 8*8 brush for PatBlt using the
* face color and highlight color.
*/
bmi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth=8;
bmi.bmiHeader.biHeight=8;
bmi.bmiHeader.biPlanes=1;
bmi.bmiHeader.biBitCount=1;
bmi.bmiHeader.biCompression=BI_RGB;
bmi.bmiHeader.biSizeImage=0;
bmi.bmiHeader.biXPelsPerMeter=0;
bmi.bmiHeader.biYPelsPerMeter=0;
bmi.bmiHeader.biClrUsed=0;
bmi.bmiHeader.biClrImportant=0;
bmi.bmiColors[0].rgbBlue=GetBValue(rgbFace);
bmi.bmiColors[0].rgbGreen=GetGValue(rgbFace);
bmi.bmiColors[0].rgbRed=GetRValue(rgbFace);
bmi.bmiColors[0].rgbReserved=0;
bmi.bmiColors[1].rgbBlue=GetBValue(rgbHilight);
bmi.bmiColors[1].rgbGreen=GetGValue(rgbHilight);
bmi.bmiColors[1].rgbRed=GetRValue(rgbHilight);
bmi.bmiColors[1].rgbReserved=0;
//Create the byte array for CreateDIBitmap.
patGray[6]=patGray[4]=patGray[2]=patGray[0]=0x5555AAAAL;
patGray[7]=patGray[5]=patGray[3]=patGray[1]=0xAAAA5555L;
//Create the bitmap
hDC=::GetDC(NULL);
hBmp=::CreateDIBitmap(hDC,&bmi.bmiHeader,CBM_INIT,patGray,
(LPBITMAPINFO)&bmi,DIB_RGB_COLORS);
::ReleaseDC(NULL,hDC);
//Create the brush from the bitmap
if(NULL!=hBmp)
{
hBrush=CreatePatternBrush(hBmp);
DeleteObject(hBmp);
}
return hBrush;
}
void COXBitmapMenu::DrawBackground(CDC* pDC, UINT nState, COXImageInfo* pImageInfo,
CRect itemRect, CRect buttonRect)
{
GetMenuSkin()->DrawBackground(pDC, nState, pImageInfo, itemRect, buttonRect, this);
}
void COXBitmapMenu::DrawButton(CDC* pDC, UINT nState, COXImageInfo* pImageInfo,
CRect buttonRect)
{
GetMenuSkin()->DrawButton(pDC, nState, pImageInfo, buttonRect, this);
}
void COXBitmapMenu::DrawImage(CDC* pDC, UINT nState, COXImageInfo* pImageInfo,
CRect imageRect)
{
GetMenuSkin()->DrawImage(pDC, nState, pImageInfo, imageRect, this);
}
void COXBitmapMenu::DrawText(CDC* pDC, UINT nState,
CString sText, CRect text1Rect, CRect text2Rect)
{
GetMenuSkin()->DrawText(pDC, nState, sText, text1Rect, text2Rect, this);
}
void COXBitmapMenu::DrawSeparator(CDC* pDC, CRect itemRect)
{
GetMenuSkin()->DrawSeparator(pDC, itemRect, this);
}
void COXBitmapMenu::DrawCustomized(CDC* pDC, CRect itemRect)
{
GetMenuSkin()->DrawCustomized(pDC, itemRect, this);
}
void COXBitmapMenu::DrawInsertMark(CDC* pDC, CRect itemRect, BOOL bBefore)
{
GetMenuSkin()->DrawInsertMark(pDC, itemRect, bBefore, this);
}
void COXBitmapMenu::DrawSubmenuItem(CDC* pDC, UINT nState, CString sText,
COXImageInfo* pImageInfo,
CRect itemRect, CRect buttonRect,
CRect text1Rect, CRect text2Rect)
{
GetMenuSkin()->DrawSubmenuItem(pDC, nState, sText, pImageInfo, itemRect, buttonRect,
text1Rect, text2Rect, this);
}
void COXBitmapMenu::DrawExpansionItem(CDC* pDC, CRect itemRect, UINT nState)
{
GetMenuSkin()->DrawExpansionItem(pDC, itemRect, nState, this);
}
void COXBitmapMenu::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
{
OXDIMENSIONCONSTANTS& oxdc = GetMenuSkin()->GetDimentionConstants();
ASSERT(lpMeasureItemStruct != NULL);
COXItemInfo* pItemInfo=(COXItemInfo*)lpMeasureItemStruct->itemData;
if(pItemInfo)
{
ASSERT(AfxIsValidAddress(pItemInfo, sizeof(COXItemInfo)));
COXImageInfo* pImageInfo=pItemInfo->GetImageInfo();
int nImageWidth=0;
int nImageHeight=0;
if(pImageInfo != NULL)
{
IMAGEINFO ii;
::ZeroMemory(&ii, sizeof(ii));
pImageInfo->GetImageList()->GetImageInfo(pImageInfo->GetIndex(),&ii);
nImageWidth=ii.rcImage.right - ii.rcImage.left + 2;
nImageHeight=ii.rcImage.bottom - ii.rcImage.top + 2;
}
lpMeasureItemStruct->itemWidth=
oxdc.m_nGapLeftBitmap+m_nBitmapExtent+oxdc.m_nGapBitmapText+
m_nStringExtent+(m_nAcceleratorExtent ? oxdc.m_nGapTextAcclrtr : 0)+
m_nAcceleratorExtent+oxdc.m_nGapAcclrtrRight;
if(lpMeasureItemStruct->itemID==0 || lpMeasureItemStruct->itemID==0xffff)
{
// separator
lpMeasureItemStruct->itemHeight=oxdc.m_nSeparatorHeight;
}
else
{
// item with text
lpMeasureItemStruct->itemHeight=__max(nImageHeight+oxdc.m_nGapVertBitmap,
m_nTextHeight+oxdc.m_nGapVertText);
if ((((int)lpMeasureItemStruct->itemID)&0x0000ffff)==ID_OX_SHOWALLITEMS)
GetMenuSkin()->AdjustExpansionItemHeight(lpMeasureItemStruct->itemHeight, this);
}
}
else if (IsPopupItem(lpMeasureItemStruct->itemID))
lpMeasureItemStruct->itemHeight = m_nTextHeight + oxdc.m_nGapVertText;
}
void COXBitmapMenu::CalcExtents()
{
UINT nItemCount=GetMenuItemCount();
CString sText;
CString sBeforeTab;
CString sAfterTab;
int nTabCharIndex=0;
m_nStringExtent=0;
m_nAcceleratorExtent=0;
m_nBitmapExtent=0;
MENUITEMINFO mii={ sizeof(MENUITEMINFO) };
CFont Font, boldFont;
NONCLIENTMETRICS ncm={ sizeof(NONCLIENTMETRICS) };
COXItemInfo* pItemInfo=NULL;
COXImageInfo* pImageInfo=NULL;
IMAGEINFO ii={ 0 };
VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0));
VERIFY(Font.CreateFontIndirect(&ncm.lfMenuFont));
ncm.lfMenuFont.lfWeight = FW_BOLD; // make the font bold
VERIFY(boldFont.CreateFontIndirect(&ncm.lfMenuFont));
CWnd* pMainWnd=AfxGetThread()->GetMainWnd();
CDC* pDC=pMainWnd->GetDC();
CSize TextExt;
for(UINT nItemIndex=0; nItemIndex < nItemCount; nItemIndex++)
{
CFont* pOldFont;
if (GetDefaultItem(GMDI_USEDISABLED, MF_BYPOSITION) == nItemIndex)
pOldFont = pDC->SelectObject(&boldFont);
else
pOldFont = pDC->SelectObject(&Font);
mii.fMask=MIIM_TYPE|MIIM_DATA|MIIM_SUBMENU;
mii.cch=300;
mii.dwTypeData=sText.GetBuffer(mii.cch);
// ... zero-terminate string
mii.dwTypeData[0]=_T('\0');
::GetMenuItemInfo(GetSafeHmenu(), nItemIndex, TRUE, &mii);
sText.ReleaseBuffer();
if(mii.fType & MFT_SEPARATOR)
continue;
pItemInfo=(COXItemInfo*)(mii.dwItemData);
if(pItemInfo)
{
pImageInfo=pItemInfo->GetImageInfo();
if(pImageInfo)
{
pImageInfo->GetImageList()->GetImageInfo(pImageInfo->GetIndex(),&ii);
m_nBitmapExtent=__max(m_nBitmapExtent, __max(GetMenuSkin()->GetDimentionConstants().m_nMinBitmapWidth,ii.rcImage.right-ii.rcImage.left));
}
sText=pItemInfo->GetText();
}
nTabCharIndex=sText.Find(_T('\t'));
if(nTabCharIndex != -1)
{
sBeforeTab=sText.Left(nTabCharIndex);
sAfterTab=sText.Mid(nTabCharIndex + 1);
}
else
{
sBeforeTab=sText;
if(mii.hSubMenu!=NULL)
sAfterTab=_T("W");
else
sAfterTab.Empty();
}
CRect text1Rect(0,0,0,0);
CRect text2Rect(0,0,0,0);
pDC->DrawText(sBeforeTab, text1Rect, DT_CALCRECT | DT_SINGLELINE);
pDC->DrawText(sAfterTab, text2Rect, DT_CALCRECT | DT_SINGLELINE);
m_nStringExtent=__max(m_nStringExtent, text1Rect.Width());
m_nAcceleratorExtent=__max(m_nAcceleratorExtent, text2Rect.Width());
pDC->SelectObject(pOldFont);
}
TextExt=pDC->GetTextExtent(_T("A"));
m_nTextHeight=TextExt.cy;
pMainWnd->ReleaseDC(pDC);
}
void COXBitmapMenu::AddItemInfo(COXItemInfo* pItemInfo)
{
m_ItemInfoList.AddTail(pItemInfo);
}
/////////////////////////////////////////////////////////////////////////////
// COXBitmapMenu idle update through CBitmapMenuCmdUI class
class OX_CLASS_DECL CBitmapMenuCmdUI : public CCmdUI // class private to this file !
{
public: // re-implementations only
virtual void SetText(LPCTSTR lpszText);
};
void CBitmapMenuCmdUI::SetText(LPCTSTR lpszText)
{
ASSERT(lpszText != NULL);
ASSERT(AfxIsValidString(lpszText));
ASSERT(m_pMenu->IsKindOf(RUNTIME_CLASS(COXBitmapMenu)));
if(m_pMenu != NULL)
{
if(m_pSubMenu != NULL)
return; // don't change popup menus indirectly
MENUITEMINFO mii={ sizeof(mii) };
mii.fMask=MIIM_TYPE|MIIM_DATA;
::GetMenuItemInfo(m_pMenu->GetSafeHmenu(),m_nIndex,TRUE,&mii);
if(mii.fType == MFT_OWNERDRAW)
{
COXItemInfo* pItemInfo=(COXItemInfo*)(mii.dwItemData);
ASSERT(pItemInfo != NULL);
pItemInfo->SetText(lpszText);
}
else
{
CCmdUI::SetText(lpszText);
}
}
}
void COXBitmapMenu::OnUpdateCmdUI(CWnd* pWnd, UINT /*nIndex*/, BOOL bSysMenu)
{
// Code almost entirely copied from CFrameWnd::OnInitPopup
if(bSysMenu)
{
return; // don't support system menu
}
// check the enabled state of various menu items
CBitmapMenuCmdUI state;
state.m_pMenu=this;
ASSERT(state.m_pOther == NULL);
ASSERT(state.m_pParentMenu == NULL);
// determine if menu is popup in top-level menu and set m_pOther to
// it if so (m_pParentMenu == NULL indicates that it is secondary popup)
HMENU hParentMenu;
if(AfxGetThreadState()->m_hTrackingMenu == m_hMenu)
{
state.m_pParentMenu=this; // parent == child for tracking popup
}
else if((hParentMenu=::GetMenu(pWnd->m_hWnd)) != NULL)
{
CWnd* pParent=pWnd->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) == m_hMenu)
{
// when popup is found, m_pParentMenu is containing menu
state.m_pParentMenu=CMenu::FromHandle(hParentMenu);
break;
}
}
}
}
state.m_nIndexMax=GetMenuItemCount();
for (state.m_nIndex=0; state.m_nIndex < state.m_nIndexMax; state.m_nIndex++)
{
state.m_nID=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)
{
// possibly a popup menu, route to first item of that popup
state.m_pSubMenu=GetSubMenu(state.m_nIndex);
if(state.m_pSubMenu == NULL ||
(state.m_nID=state.m_pSubMenu->GetMenuItemID(0)) == 0 ||
state.m_nID == (UINT)-1)
{
continue; // first item of popup can't be routed to
}
state.DoUpdate(pWnd, FALSE); // popups are never auto disabled
}
else
{
// normal menu item
// Auto enable/disable if frame window has 'm_bAutoMenuEnable'
// set and command is _not_ a system command.
state.m_pSubMenu=NULL;
state.DoUpdate(pWnd,
((CFrameWnd*)pWnd)->m_bAutoMenuEnable && state.m_nID<0xF000);
}
// adjust for menu deletions and additions
UINT nCount=GetMenuItemCount();
if(nCount < state.m_nIndexMax)
{
state.m_nIndex -= (state.m_nIndexMax - nCount);
while (state.m_nIndex < nCount &&
GetMenuItemID(state.m_nIndex) == state.m_nID)
{
state.m_nIndex++;
}
}
state.m_nIndexMax=nCount;
}
}
int COXBitmapMenu::SetCustomizedItem(int nIndex)
{
int nOldCustomizedItemIndex=m_nCustomizedItemIndex;
m_nCustomizedItemIndex=nIndex;
if(m_pPopupWnd!=NULL && ::IsWindow(m_pPopupWnd->GetSafeHwnd()))
{
if(nOldCustomizedItemIndex!=m_nCustomizedItemIndex)
{
if(nOldCustomizedItemIndex!=-1)
m_pPopupWnd->RedrawItem(nOldCustomizedItemIndex);
if(m_nCustomizedItemIndex!=-1)
m_pPopupWnd->RedrawItem(m_nCustomizedItemIndex);
}
SendCustomizeNotification(ID_OXCUSTBM_SET_CUSTOMIZE_ITEM);
}
return nOldCustomizedItemIndex;
}
BOOL COXBitmapMenu::DisplayCustomizeItemContextMenu(int nItemIndex, CPoint point)
{
ASSERT(nItemIndex>=0 && nItemIndex<(int)GetMenuItemCount());
COXBitmapMenuOrganizer* pOrganizer=
COXBitmapMenuOrganizer::FindOrganizer(AfxGetMainWnd()->GetSafeHwnd());
ASSERT(pOrganizer!=NULL);
CString sText;
MENUITEMINFO mii={ sizeof(MENUITEMINFO) };
mii.fMask=MIIM_TYPE|MIIM_DATA|MIIM_ID|MIIM_SUBMENU;
mii.cch=300;
mii.dwTypeData=sText.GetBuffer(mii.cch);
// ... zero-terminate string
mii.dwTypeData[0]=_T('\0');
VERIFY(::GetMenuItemInfo(GetSafeHmenu(),nItemIndex,TRUE,&mii));
sText.ReleaseBuffer();
COXItemInfo* pItemInfo=(COXItemInfo*)(mii.dwItemData);
ASSERT(AfxIsValidAddress(pItemInfo,sizeof(COXItemInfo)));
sText=pItemInfo->GetText();
// don't add most recent files used
if((int)mii.wID>=ID_FILE_MRU_FILE1 && (int)mii.wID<=ID_FILE_MRU_FILE16)
{
return FALSE;
}
// don't add MDIChild windows menu items
if((int)mii.wID>=AFX_IDM_FIRST_MDICHILD && mii.hSubMenu==NULL)
{
return FALSE;
}
CMenu menu;
if(!menu.CreatePopupMenu())
return FALSE;
// populate menu
CString sItem;
VERIFY(sItem.LoadString(IDS_OX_CUSTBM_DELETE));
VERIFY(menu.AppendMenu(MF_STRING,ID_OXCUSTBM_DELETE,sItem));
if((mii.fType&MFT_SEPARATOR)==0)
{
VERIFY(menu.AppendMenu(MF_SEPARATOR));
VERIFY(sItem.LoadString(IDS_OX_CUSTBM_APPEARANCE));
VERIFY(menu.AppendMenu(MF_STRING,ID_OXCUSTBM_APPEARANCE,
sItem));
VERIFY(menu.AppendMenu(MF_SEPARATOR));
if(pOrganizer->IsShowOnlyRecentlyUsedItems())
{
VERIFY(sItem.LoadString(IDS_OX_CUSTBM_RECENTLY_USED));
VERIFY(menu.AppendMenu(MF_STRING|
(pOrganizer->IsRecentlyUsed(this,nItemIndex) ? MF_CHECKED :
MF_UNCHECKED),ID_OXCUSTBM_RECENTLY_USED,sItem));
VERIFY(menu.AppendMenu(MF_SEPARATOR));
}
BOOL bSeparatorBefore=FALSE;
if(nItemIndex>0)
{
MENUITEMINFO mii={ sizeof(MENUITEMINFO) };
mii.fMask=MIIM_TYPE;
mii.cch=300;
mii.dwTypeData=sText.GetBuffer(mii.cch);
// ... zero-terminate string
mii.dwTypeData[0]=_T('\0');
VERIFY(::GetMenuItemInfo(GetSafeHmenu(),nItemIndex-1,TRUE,&mii));
sText.ReleaseBuffer();
bSeparatorBefore=((mii.fType&MFT_SEPARATOR)==0);
}
VERIFY(sItem.LoadString(IDS_OX_CUSTBM_SEPARATOR_BEFORE));
VERIFY(menu.AppendMenu(MF_STRING|(bSeparatorBefore ? 0 : MF_GRAYED),
ID_OXCUSTBM_SEPARATOR_BEFORE,sItem));
BOOL bSeparatorAfter=FALSE;
if(nItemIndex<(int)(GetMenuItemCount()-1))
{
MENUITEMINFO mii={ sizeof(MENUITEMINFO) };
mii.fMask=MIIM_TYPE;
mii.cch=300;
mii.dwTypeData=sText.GetBuffer(mii.cch);
// ... zero-terminate string
mii.dwTypeData[0]=_T('\0');
VERIFY(::GetMenuItemInfo(GetSafeHmenu(),nItemIndex+1,TRUE,&mii));
sText.ReleaseBuffer();
bSeparatorAfter=((mii.fType&MFT_SEPARATOR)==0);
}
VERIFY(sItem.LoadString(IDS_OX_CUSTBM_SEPARATOR_AFTER));
VERIFY(menu.AppendMenu(MF_STRING|(bSeparatorAfter ? 0 : MF_GRAYED),
ID_OXCUSTBM_SEPARATOR_AFTER,sItem));
}
CWnd* pWndOwner=NULL;
if(m_pPopupWnd!=NULL && ::IsWindow(m_pPopupWnd->GetSafeHwnd()))
pWndOwner=m_pPopupWnd;
menu.TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_RIGHTBUTTON,
point.x,point.y,pWndOwner);
return TRUE;
}
void COXBitmapMenu::OnCustBMDelete()
{
ASSERT(IsInCustomizationMode());
int nCustomizedItemIndex=GetCustomizedItem();
ASSERT(nCustomizedItemIndex!=-1);
if(SendCustomizeNotification(ID_OXCUSTBM_DELETE))
return;
VERIFY(DeleteMenu(nCustomizedItemIndex,MF_BYPOSITION));
m_nCustomizedItemIndex=-1;
UpdateContents();
}
void COXBitmapMenu::OnCustBMAppearance()
{
ASSERT(IsInCustomizationMode());
int nCustomizedItemIndex=GetCustomizedItem();
ASSERT(nCustomizedItemIndex!=-1);
UNUSED(nCustomizedItemIndex);
SendCustomizeNotification(ID_OXCUSTBM_APPEARANCE);
}
void COXBitmapMenu::OnCustBMSeparatorBefore()
{
ASSERT(IsInCustomizationMode());
int nCustomizedItemIndex=GetCustomizedItem();
ASSERT(nCustomizedItemIndex!=-1);
if(SendCustomizeNotification(ID_OXCUSTBM_SEPARATOR_BEFORE))
return;
VERIFY(InsertMenu(nCustomizedItemIndex,MF_SEPARATOR|MF_BYPOSITION));
UpdateContents();
SetCustomizedItem(nCustomizedItemIndex+1);
}
void COXBitmapMenu::OnCustBMSeparatorAfter()
{
ASSERT(IsInCustomizationMode());
int nCustomizedItemIndex=GetCustomizedItem();
ASSERT(nCustomizedItemIndex!=-1);
if(SendCustomizeNotification(ID_OXCUSTBM_SEPARATOR_AFTER))
return;
VERIFY(InsertMenu(nCustomizedItemIndex+1,MF_SEPARATOR|MF_BYPOSITION));
UpdateContents();
}
void COXBitmapMenu::OnCustBMRecentlyUsed()
{
ASSERT(IsInCustomizationMode());
int nCustomizedItemIndex=GetCustomizedItem();
ASSERT(nCustomizedItemIndex!=-1);
if(SendCustomizeNotification(ID_OXCUSTBM_RECENTLY_USED))
return;
COXBitmapMenuOrganizer* pOrganizer=
COXBitmapMenuOrganizer::FindOrganizer(AfxGetMainWnd()->GetSafeHwnd());
ASSERT(pOrganizer!=NULL);
if(pOrganizer->IsRecentlyUsed(this,nCustomizedItemIndex))
{
VERIFY(pOrganizer->
ExcludeFromRecentlyUsed(this,nCustomizedItemIndex));
}
else
{
VERIFY(pOrganizer->
AddToRecentlyUsed(this,nCustomizedItemIndex));
}
UpdateContents();
}
LRESULT COXBitmapMenu::SendCustomizeNotification(UINT nCustomizeCmdID)
{
ASSERT(GetPopupWnd()!=NULL);
HWND hWnd=m_hWndCustomizeOrganizer;
if(hWnd==NULL)
{
hWnd=AfxGetMainWnd()->GetSafeHwnd();
}
if(hWnd==NULL)
return (LRESULT)0;
NMBMCUSTOMIZE nmbmCustomize;
nmbmCustomize.nmhdr.code=OXBMN_CUSTOMIZECMD;
nmbmCustomize.nmhdr.hwndFrom=GetPopupWnd()->GetSafeHwnd();
nmbmCustomize.nmhdr.idFrom=::GetDlgCtrlID(hWnd);
nmbmCustomize.nCustomizeEventID=nCustomizeCmdID;
return ::SendMessage(hWnd,WM_NOTIFY,(WPARAM)nmbmCustomize.nmhdr.idFrom,
(LPARAM)&nmbmCustomize);
}
LONG COXBitmapMenu::OnDragEnter(WPARAM wParam, LPARAM lParam)
{
// toolbar must be in customizable state
if(!IsCustomizable())
return (LONG)FALSE;
// set flag that specifies that drag'n'drop operation is active
m_bDragDropOperation=TRUE;
return OnDragOver(wParam,lParam);
}
LONG COXBitmapMenu::OnDragOver(WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(wParam);
// toolbar must be in customizable state
if(!IsCustomizable())
return (LONG)FALSE;
// lParam is the pointer to SHBDROPTARGETACTION structure
LPSHBDROPTARGETACTION pSHBDTAction=(LPSHBDROPTARGETACTION)lParam;
ASSERT(pSHBDTAction!=NULL);
pSHBDTAction->result=(LRESULT)DROPEFFECT_NONE;
#ifdef OX_CUSTOMIZE_COMMANDS
// Can we use this object?
if(pSHBDTAction->pDataObject->
IsDataAvailable(COXDragDropCommands::m_cfCommandButton))
{
// analize the current cursor position
//
BOOL bBefore=TRUE;
int nItemIndex=HitTest(&pSHBDTAction->point,&bBefore);
int nInsertMarkIndex=(bBefore ? nItemIndex : nItemIndex+1);
SetInsertMark(nInsertMarkIndex);
// Check if the control key was pressed
if((pSHBDTAction->dwKeyState & MK_CONTROL)==MK_CONTROL)
pSHBDTAction->result=(LRESULT)DROPEFFECT_COPY;
else
pSHBDTAction->result=(LRESULT)DROPEFFECT_MOVE;
}
#endif // OX_CUSTOMIZE_COMMANDS
return (LONG)TRUE;
}
LONG COXBitmapMenu::OnDragLeave(WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(wParam);
if(!IsCustomizable())
return (LONG)FALSE;
// lParam is the pointer to SHBDROPTARGETACTION structure
LPSHBDROPTARGETACTION pSHBDTAction=(LPSHBDROPTARGETACTION)lParam;
ASSERT(pSHBDTAction!=NULL);
SetInsertMark(-1);
// reset flag that specifies that drag'n'drop operation is active
m_bDragDropOperation=FALSE;
return (LONG)TRUE;
}
LONG COXBitmapMenu::OnDrop(WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(wParam);
if(!IsCustomizable())
return (LONG)FALSE;
// lParam is the pointer to SHBDROPTARGETACTION structure
LPSHBDROPTARGETACTION pSHBDTAction=(LPSHBDROPTARGETACTION)lParam;
ASSERT(pSHBDTAction!=NULL);
pSHBDTAction->result=(LRESULT)FALSE;
#ifdef OX_CUSTOMIZE_COMMANDS
// if dragged item is to be copied or moved
if((pSHBDTAction->dropEffect&DROPEFFECT_COPY)!=0 ||
(pSHBDTAction->dropEffect&DROPEFFECT_MOVE)!=0)
{
// data must be in the specific format
ASSERT(pSHBDTAction->pDataObject->
IsDataAvailable(COXDragDropCommands::m_cfCommandButton));
int nItemIndex=GetInsertMark();
if(nItemIndex!=-1 || GetMenuItemCount()==0)
{
// Get the drag item info
//
HGLOBAL hgData=pSHBDTAction->pDataObject->
GetGlobalData(COXDragDropCommands::m_cfCommandButton);
ASSERT(hgData!=NULL);
// lock it
BYTE* lpItemData=(BYTE*)::GlobalLock(hgData);
if(!SendCustomizeNotification(ID_OXCUSTBM_INSERT_ITEM))
{
RetrieveDragDropMenuItem(lpItemData,GetSafeHmenu(),nItemIndex);
if(m_bDragDropOwner && m_nCustomizedItemIndex>=nItemIndex)
{
ASSERT(m_nCustomizedItemIndex!=-1);
m_nCustomizedItemIndex++;
ASSERT(GetDraggedItem()!=-1);
SetDraggedItem(GetDraggedItem()+1);
}
}
// unlock it
::GlobalUnlock(hgData);
// free it
::GlobalFree(hgData);
// remove insert mark
SetInsertMark(-1);
// drag'n'drop operation completed successfully
pSHBDTAction->result=(LRESULT)TRUE;
}
else
{
pSHBDTAction->result=(LRESULT)FALSE;
}
}
#endif // OX_CUSTOMIZE_COMMANDS
m_bDragDropOperation=FALSE;
// we handled the message
return (LONG)TRUE;
}
void COXBitmapMenu::RetrieveDragDropMenuItem(BYTE*& lpData, HMENU hMenu,
int nItemIndex)
{
ASSERT(lpData!=NULL);
ASSERT(hMenu!=NULL);
ASSERT(::IsMenu(hMenu));
COXBitmapMenuOrganizer* pOrganizer=
COXBitmapMenuOrganizer::FindOrganizer(AfxGetMainWnd()->GetSafeHwnd());
ASSERT(pOrganizer!=NULL);
while(TRUE)
{
// get button command ID
int nCommandID=*(int*)lpData;
lpData+=sizeof(int);
// get button text
CString sText((LPTSTR)lpData);
lpData+=sText.GetLength()+sizeof(TCHAR);
if(sText.IsEmpty() && nCommandID!=0)
{
HINSTANCE hInstance=
AfxFindResourceHandle(MAKEINTRESOURCE(nCommandID),RT_STRING);
ASSERT(hInstance!=NULL);
sText.LoadString(nCommandID);
int nPosition=sText.Find(_T('\n'));
if(nPosition!=-1)
sText=sText.Mid(nPosition+1);
}
ASSERT(!sText.IsEmpty() || nCommandID==0);
// get button image index
int nImageIndex=*(int*)lpData;
lpData+=sizeof(int);
UNREFERENCED_PARAMETER(nImageIndex);
// get button style
BYTE fsStyle=*(BYTE*)lpData;
lpData+=sizeof(BYTE);
UNREFERENCED_PARAMETER(fsStyle);
// get finish flag
int nFinish=*(int*)lpData;
lpData+=sizeof(int);
// update menu
if(nCommandID==-1)
{
HMENU hSubMenu=::CreatePopupMenu();
ASSERT(hSubMenu!=NULL);
pOrganizer->m_arrCreatedPopupMenus.Add(hSubMenu);
VERIFY(::InsertMenu(hMenu,nItemIndex,
MF_BYPOSITION|MF_POPUP|MF_STRING,(UINT_PTR)hSubMenu,sText)!=0);
/*
CMenu* pMenu=CMenu::FromHandle(hMenu);
ASSERT(pMenu!=NULL);
COXBitmapMenu* pBitmapMenu=DYNAMIC_DOWNCAST(COXBitmapMenu,pMenu);
if(pBitmapMenu!=NULL)
{
pOrganizer->ConvertBitmapMenu(pBitmapMenu,FALSE);
}
*/
if(nFinish!=0)
{
RetrieveDragDropMenuItem(lpData,hSubMenu,0);
}
}
else
{
VERIFY(::InsertMenu(hMenu,nItemIndex,
MF_BYPOSITION|(nCommandID==0 ? MF_SEPARATOR : MF_STRING),
(UINT)nCommandID,sText)!=0);
}
nItemIndex++;
if(nFinish==0 || nFinish==2)
break;
}
CMenu* pMenu=CMenu::FromHandle(hMenu);
ASSERT(pMenu!=NULL);
COXBitmapMenu* pBitmapMenu=DYNAMIC_DOWNCAST(COXBitmapMenu,pMenu);
if(pBitmapMenu==NULL)
{
pOrganizer->OnInitMenuPopup(pMenu,0,FALSE);
pMenu=CMenu::FromHandle(hMenu);
pBitmapMenu=DYNAMIC_DOWNCAST(COXBitmapMenu,pMenu);
}
ASSERT(pBitmapMenu!=NULL);
pBitmapMenu->UpdateContents();
}
int COXBitmapMenu::SetInsertMark(int nItemIndex)
{
ASSERT(nItemIndex>=-1 && nItemIndex<=(int)GetMenuItemCount());
int nOldInsertMark=m_nInsertMarkIndex;
m_nInsertMarkIndex=nItemIndex;
if(nOldInsertMark!=m_nInsertMarkIndex)
{
if(m_pPopupWnd!=NULL && ::IsWindow(m_pPopupWnd->GetSafeHwnd()))
{
if(nOldInsertMark!=-1)
{
int nInsertMark=nOldInsertMark;
if(nInsertMark==(int)GetMenuItemCount())
{
nInsertMark--;
}
m_pPopupWnd->RedrawItem(nInsertMark);
if(nOldInsertMark!=0 && nOldInsertMark!=(int)GetMenuItemCount() &&
nOldInsertMark!=m_nInsertMarkIndex+1)
{
m_pPopupWnd->RedrawItem(nOldInsertMark-1);
}
}
if(m_nInsertMarkIndex!=-1)
{
int nInsertMark=m_nInsertMarkIndex;
if(nInsertMark==(int)GetMenuItemCount())
nInsertMark--;
m_pPopupWnd->RedrawItem(nInsertMark);
if(m_nInsertMarkIndex!=0 &&
m_nInsertMarkIndex!=(int)GetMenuItemCount() &&
m_nInsertMarkIndex!=nOldInsertMark+1)
{
m_pPopupWnd->RedrawItem(m_nInsertMarkIndex-1);
}
}
}
SendCustomizeNotification(ID_OXCUSTBM_SET_INSERT_MARK);
}
return nOldInsertMark;
}
int COXBitmapMenu::HitTest(LPPOINT ppt, BOOL* pbBefore/*=NULL*/)
{
int nItemIndex=-1;
int nHeight=0;
for(int nIndex=0; nIndex<(int)GetMenuItemCount(); nIndex++)
{
MENUITEMINFO mii={ sizeof(mii) };
mii.fMask=MIIM_DATA;
VERIFY(::GetMenuItemInfo(GetSafeHmenu(),nIndex,TRUE,&mii));
MEASUREITEMSTRUCT mis;
mis.CtlType=ODT_MENU;
mis.itemData=mii.dwItemData;
mis.itemID=GetMenuItemID(nIndex);
mis.itemHeight=(UINT)-1;
mis.itemWidth=(UINT)-1;
MeasureItem(&mis);
nHeight+=mis.itemHeight;
if(ppt->y<=nHeight)
{
nItemIndex=nIndex;
if(pbBefore!=NULL)
*pbBefore=(ppt->y<=nHeight-(int)mis.itemHeight/2);
break;
}
}
return nItemIndex;
}
void COXBitmapMenu::UpdateContents()
{
COXBitmapMenuOrganizer* pOrganizer=
COXBitmapMenuOrganizer::FindOrganizer(AfxGetMainWnd()->GetSafeHwnd());
if(pOrganizer!=NULL)
{
pOrganizer->ConvertBitmapMenu(this,FALSE);
}
if(m_pPopupWnd!=NULL && ::IsWindow(m_pPopupWnd->GetSafeHwnd()))
{
m_pPopupWnd->OnMenuChanged();
}
}
void COXBitmapMenu::OnBeginDragDrop(int nIndex)
{
ASSERT(nIndex>=0 && nIndex<(int)GetMenuItemCount());
ASSERT(m_pPopupWnd!=NULL && ::IsWindow(m_pPopupWnd->GetSafeHwnd()));
UNUSED(nIndex);
// mark the control as the one that launched drag'n'drop operation
m_bDragDropOwner=TRUE;
#ifdef OX_CUSTOMIZE_COMMANDS
CString sText;
MENUITEMINFO mii={ sizeof(mii) };
mii.fMask=MIIM_DATA|MIIM_TYPE|MIIM_ID|MIIM_SUBMENU;
mii.cch=300;
mii.dwTypeData=sText.GetBuffer(mii.cch);
VERIFY(::GetMenuItemInfo(GetSafeHmenu(),nIndex,TRUE,&mii));
sText.ReleaseBuffer();
// don't allow to drag most recent files used
if((int)mii.wID>=ID_FILE_MRU_FILE1 && (int)mii.wID<=ID_FILE_MRU_FILE16)
{
// unmark as the control which launched drag'n'drop operation
m_bDragDropOwner=FALSE;
return;
}
// don't allow to drag MDIChild windows menu items
if((int)mii.wID>=AFX_IDM_FIRST_MDICHILD && mii.hSubMenu==NULL)
{
// unmark as the control which launched drag'n'drop operation
m_bDragDropOwner=FALSE;
return;
}
COXItemInfo* pItemInfo=(COXItemInfo*)(mii.dwItemData);
ASSERT(AfxIsValidAddress(pItemInfo,sizeof(COXItemInfo)));
ASSERT(!pItemInfo->GetText().IsEmpty() || mii.fType&MFT_SEPARATOR);
CMenu* pSubmenu=GetSubMenu(nIndex);
if(pSubmenu!=NULL)
{
COXBitmapMenu* pBMSubmenu=DYNAMIC_DOWNCAST(COXBitmapMenu,pSubmenu);
if(pBMSubmenu!=NULL)
{
if(pBMSubmenu->GetPopupWnd()!=NULL)
{
pBMSubmenu->GetPopupWnd()->ResetPopupMenu();
}
}
}
COleDataSource* pDataSource=
COXDragDropCommands::PrepareDragDropData(pItemInfo->GetText(),
pItemInfo->GetImageInfo()->GetIndex(),GetMenuItemID(nIndex),0,
GetSubMenu(nIndex)->GetSafeHmenu());
ASSERT(pDataSource!=NULL);
m_bDragDropOperation=TRUE;
SetDraggedItem(nIndex);
DROPEFFECT dropEffect=
COXDragDropCommands::DoDragDrop(pDataSource,GetDropSource(m_pPopupWnd));
if(DROPEFFECT_MOVE==dropEffect || (DROPEFFECT_NONE==dropEffect &&
::GetKeyState(VK_LBUTTON)>=0 && !m_bDragDropOperation))
{
if(!SendCustomizeNotification(ID_OXCUSTBM_DELETE_ITEM))
{
int nDraggedItemIndex=GetDraggedItem();
// delete item if it was moved
VERIFY(DeleteMenu(nDraggedItemIndex,MF_BYPOSITION));
m_nCustomizedItemIndex=-1;
UpdateContents();
}
}
SetDraggedItem(-1);
//delete drag source (we are responsible to do that)
delete pDataSource;
#endif // OX_CUSTOMIZE_COMMANDS
// unmark as the control which launched drag'n'drop operation
m_bDragDropOwner=FALSE;
}
COXMenuSkin* COXBitmapMenu::GetMenuSkin()
{
// Check if the app is derived from COXSkinnedApp
COXSkinnedApp* pSkinnedApp = DYNAMIC_DOWNCAST(COXSkinnedApp, AfxGetApp());
if (pSkinnedApp != NULL && pSkinnedApp->GetCurrentSkin() != NULL)
return pSkinnedApp->GetCurrentSkin()->GetMenuSkin();
else
{
// Create a classic skin for this class if not created already
if (m_pMenuSkin == NULL)
m_pMenuSkin = new COXMenuSkinClassic();
return m_pMenuSkin;
}
}
// Returns TRUE if the given item is a popup menu (has a submenu)
BOOL COXBitmapMenu::IsPopupItem(UINT nItemID)
{
if (nItemID == (UINT)-1)
return TRUE;
MENUITEMINFO mii;
::memset(&mii, 0, sizeof(MENUITEMINFO));
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_SUBMENU;
GetMenuItemInfo(nItemID, &mii);
if (mii.hSubMenu != NULL)
return TRUE;
else
return FALSE;
}
void COXBitmapMenu::RestoreMDI()
{
CMDIFrameWnd* pMainWnd = (CMDIFrameWnd*)AfxGetMainWnd();
CMDIChildWnd * active = pMainWnd->MDIGetActive();
active->MDIRestore();
pMainWnd->MDINext();
while(active != pMainWnd->MDIGetActive())
{
pMainWnd->MDIGetActive()->MDIRestore();
pMainWnd->MDINext();
}
}
void COXBitmapMenu::CloseMDI()
{
CMDIFrameWnd* pMainWnd = (CMDIFrameWnd*)AfxGetMainWnd();
CMDIChildWnd * active = pMainWnd->MDIGetActive();
if (active->GetActiveDocument()->IsModified())
{
CString sTitle;
active->GetActiveFrame()->GetWindowText(sTitle);
int ID = AfxMessageBox(_T("Save changes to ") + sTitle + _T(" ?"), MB_YESNOCANCEL);
switch(ID)
{
case IDCANCEL:
// Do nothing
break;
case IDYES:
active->GetActiveDocument()->DoFileSave();
// Fall through intended
case IDNO:
active->DestroyWindow();
}
}
else
{
active->DestroyWindow();
}
}
void COXBitmapMenu::MinimizeMDI()
{
CMDIFrameWnd* pMainWnd = (CMDIFrameWnd*)AfxGetMainWnd();
CMDIChildWnd * active = pMainWnd->MDIGetActive();
active->MDIRestore();
active->ShowWindow(SW_MINIMIZE);}
BOOL COXBitmapMenu::HandleMDICommandMessage(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
{
UNREFERENCED_PARAMETER(pHandlerInfo);
if (nCode == CN_UPDATE_COMMAND_UI)
{
switch(nID)
{
case ID_OXBITMAPMENU_CLOSE:
case ID_OXBITMAPMENU_MINIMIZE:
case ID_OXBITMAPMENU_RESTORE:
((CCmdUI *) pExtra)->Enable (TRUE);
return TRUE;
}
}
else
if (nCode == CN_COMMAND)
{
bool bHandled = false;
switch(nID)
{
case ID_OXBITMAPMENU_CLOSE:
CloseMDI();
bHandled = true;
break;
case ID_OXBITMAPMENU_MINIMIZE:
MinimizeMDI();
bHandled = true;
break;
case ID_OXBITMAPMENU_RESTORE:
RestoreMDI();
bHandled = true;
break;
case SC_MAXIMIZE:
return TRUE;
}
if(bHandled)
{
CMDIFrameWnd* pMainWnd = static_cast<CMDIFrameWnd*>(AfxGetMainWnd());
if(pMainWnd)
{
CMDIChildWnd* pActiveWnd = pMainWnd->MDIGetActive();
if(pActiveWnd)
{
pActiveWnd->GetSystemMenu(TRUE);
}
}
return TRUE;
}
}
return FALSE;
}
#ifndef CS_DROPSHADOW
#define CS_DROPSHADOW 0x00020000
#endif
BOOL COXBitmapMenu::RegisterWindowClass(HINSTANCE hInstance)
{
if (m_origWndProc != NULL)
return TRUE; // already registed
WNDCLASS wndclass;
if (GetClassInfo(hInstance,_T("#32768"),&wndclass))
m_origWndProc = wndclass.lpfnWndProc;
wndclass.lpfnWndProc = PopupWndProc;
wndclass.style &= ~CS_DROPSHADOW;
wndclass.style |= CS_SAVEBITS;
wndclass.hInstance = hInstance ;
RegisterClass(&wndclass);
if (GetClassInfo(hInstance,_T("#32768"),&wndclass))
return TRUE;
else
return FALSE;
}
LRESULT CALLBACK COXBitmapMenu::PopupWndProc(HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
return GetMenuSkin()->MenuPopupWndProc(m_origWndProc, hwnd, nMsg, wParam, lParam);
}
void COXBitmapMenuPopupWnd::OnNcPaint()
{
COXBitmapMenu::GetMenuSkin()->OnNcPaintCustomizePopupWnd(this);
}
BOOL COXBitmapMenu::TrackPopupMenu(COXCoolToolBar* pCoolToolBar, CWnd* pWnd, LPCRECT lpRect)
{
// Determine the selected item
int iSelectedItem = -1;
CToolBarCtrl& ctrl = pCoolToolBar->GetToolBarCtrl();
int iButtonCount = ctrl.GetButtonCount();
for (int i = 0; i < iButtonCount; i++)
{
if (ctrl.IsButtonPressed(pCoolToolBar->GetItemID(i)))
{
iSelectedItem = i;
break;
}
}
if (iSelectedItem == -1)
iSelectedItem = ctrl.CommandToIndex(pCoolToolBar->m_iLastDropDownIndex);
// Determine the rectangle of the selected item
CRect rectItem;
pCoolToolBar->GetItemRect(iSelectedItem, &rectItem);
COXMenuBar* pMenuBar = DYNAMIC_DOWNCAST(COXMenuBar, pCoolToolBar);
if (pMenuBar != NULL && iSelectedItem == -1)
{
// This is the icon item
rectItem = pMenuBar->m_iconRect;
CRect rectWindow;
pMenuBar->GetWindowRect(rectWindow);
pMenuBar->ScreenToClient(&rectWindow);
CRect rectClient;
pMenuBar->GetClientRect(rectClient);
rectItem.left += rectWindow.left - rectClient.left;
rectItem.right += rectWindow.left - rectClient.left;
rectItem.top += rectWindow.top - rectClient.top;
rectItem.bottom += rectWindow.top - rectClient.top;
rectItem.InflateRect(3, 3);
}
pCoolToolBar->ClientToScreen(&rectItem);
// Determine the position of the popup menu relative to the selected item
CPoint ptTopLeft;
UINT nFlags, nPosFlags;
DeterminePosition(this, rectItem, pCoolToolBar->m_dwStyle, ptTopLeft, nFlags, nPosFlags);
// Clear the queue of any pending messages
MSG msg;
while (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != 0)
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
COXShadowedItemWnd* pSIW = new COXShadowedItemWnd(pCoolToolBar, iSelectedItem, nPosFlags);
CRect rect;
pCoolToolBar->GetItemRect(iSelectedItem, rect);
rect.DeflateRect(0, 1);
// Save the item rectangle in screen coordinates
m_rectDropDownItem = rect;
pCoolToolBar->ClientToScreen(m_rectDropDownItem);
// Create the transparent window which will be responsible for drawing the shadow
// The transparent window must be a child of the main window
rect.InflateRect(0, 0, 4, 4);
pCoolToolBar->ClientToScreen(rect);
pSIW->CreateEx(WS_EX_TRANSPARENT | WS_EX_TOOLWINDOW, NULL, NULL, WS_CHILD | WS_VISIBLE,
rect, CWnd::GetDesktopWindow(), 0, NULL);
BOOL bResult = CMenu::TrackPopupMenu(nFlags, ptTopLeft.x, ptTopLeft.y, pWnd, lpRect);
pSIW->DestroyWindow();
delete pSIW;
pSIW = NULL;
m_rectDropDownItem.SetRectEmpty();
return bResult;
}
// Returns the size of the popup menu before it is displayed
CSize COXBitmapMenu::GetPopupMenuSize(CMenu* pMenu)
{
CSize szMenu(0, 0);
int iCount = pMenu->GetMenuItemCount();
for (int i = 0; i < iCount; i++)
{
UINT nItemID = pMenu->GetMenuItemID(i);
// Get the data member
MENUITEMINFO miinfo;
::memset(&miinfo, 0, sizeof(MENUITEMINFO));
miinfo.cbSize = sizeof(MENUITEMINFO);
miinfo.fMask = MIIM_DATA;
pMenu->GetMenuItemInfo(nItemID, &miinfo);
// Call CMenu::MeasureItem() to determine the item's dimensions
MEASUREITEMSTRUCT mi;
::memset(&mi, 0, sizeof(MEASUREITEMSTRUCT));
mi.CtlType = ODT_MENU;
mi.itemID = nItemID;
mi.itemData = miinfo.dwItemData;
pMenu->MeasureItem(&mi);
if (mi.itemHeight == 0 && DYNAMIC_DOWNCAST(COXBitmapMenu, pMenu) == NULL)
{
// This is not a COXBitmapMenu
if (nItemID == 0)
mi.itemHeight = 8; // separator
else
mi.itemHeight = 17; // normal item
}
if ((int) mi.itemWidth > szMenu.cx)
szMenu.cx = mi.itemWidth;
szMenu.cy += mi.itemHeight;
}
// Compensate for the non-client area
szMenu.cx += 18;
szMenu.cy += 6;
return szMenu;
}
void COXBitmapMenu::DeterminePosition(CMenu* pMenu, LPCRECT lpItemRect, DWORD dwStyle, CPoint& ptTopLeft, UINT& nFlags, UINT& nPosFlags)
{
// Get the rectangle of the monitor closest to the menu rectangle
HMONITOR hMonitor = ::MonitorFromRect(lpItemRect, MONITOR_DEFAULTTONEAREST);
MONITORINFO mi;
mi.cbSize = sizeof(MONITORINFO);
::GetMonitorInfo(hMonitor, &mi);
const int iMixScreenX = mi.rcMonitor.left;
const int iMinScreenY = mi.rcMonitor.top;
const int iMaxScreenX = mi.rcMonitor.right;
const int iMaxScreenY = mi.rcMonitor.bottom;
CSize sizeMenu = GetPopupMenuSize(pMenu);
ptTopLeft.x = 0;
ptTopLeft.y = 0;
nFlags = 0;
if (dwStyle & CBRS_ORIENT_HORZ)
{
// Horizontal menu
ptTopLeft.x = lpItemRect->left;
if (ptTopLeft.x < iMixScreenX)
ptTopLeft.x = iMixScreenX;
if (ptTopLeft.x + sizeMenu.cx > iMaxScreenX)
ptTopLeft.x = iMaxScreenX - sizeMenu.cx;
if (lpItemRect->bottom + sizeMenu.cy > iMaxScreenY)
{
// The popup menu should be above the item
nFlags |= TPM_BOTTOMALIGN;
nPosFlags = OX_TPM_TOP;
ptTopLeft.y = lpItemRect->top + 1;
}
else
{
// The popup menu should be below the item
nFlags |= TPM_TOPALIGN;
nPosFlags = OX_TPM_BOTTOM;
ptTopLeft.y = lpItemRect->bottom - 1;
}
}
else
{
// Vertical menu
if (lpItemRect->right + sizeMenu.cx > iMaxScreenX)
{
// The popup menu should be left of the item
nFlags |= TPM_RIGHTALIGN;
nPosFlags = OX_TPM_LEFT;
ptTopLeft.x = lpItemRect->left;
}
else
{
// The popup menu should be right of the item
nFlags |= TPM_LEFTALIGN;
nPosFlags = OX_TPM_RIGHT;
ptTopLeft.x = lpItemRect->right;
}
ptTopLeft.y = lpItemRect->top + 1;
if (ptTopLeft.y < iMinScreenY)
ptTopLeft.y = iMinScreenY;
if (ptTopLeft.y + sizeMenu.cy > iMaxScreenY)
ptTopLeft.y = iMaxScreenY - sizeMenu.cy - 1;
}
}
Reference in New Issue View Git Blame Copy Permalink