832 lines
56 KiB
C++
832 lines
56 KiB
C++
// ==========================================================================
|
||
// Class Specification : COXBitmapMenu
|
||
// ==========================================================================
|
||
|
||
// Header file : OXBitmapMenu.h
|
||
|
||
// 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.
|
||
|
||
// //////////////////////////////////////////////////////////////////////////
|
||
|
||
// Properties:
|
||
// NO Abstract class
|
||
// YES Derived from CMenu
|
||
|
||
// NO Is a Cwnd. (Its a CMenu)
|
||
// NO Two stage creation
|
||
// NO Has a message map
|
||
// NO Needs a resource
|
||
|
||
// NO Persistent objects (saveable on disk)
|
||
// NO Uses exceptions
|
||
|
||
// //////////////////////////////////////////////////////////////////////////
|
||
|
||
// Desciption :
|
||
// COXBitmapMenu implements drawing of the menu items
|
||
|
||
// Remark:
|
||
// User doesn't need to use this object directly. COXBitmapMenuOrganizer
|
||
// handles creation and destruction of COXBitmapMenu Objects.
|
||
|
||
// Prerequisites (necessary conditions):
|
||
//
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
|
||
#ifndef BITMAPMENU_H
|
||
#define BITMAPMENU_H
|
||
|
||
#if _MSC_VER >= 1000
|
||
#pragma once
|
||
#endif // _MSC_VER >= 1000
|
||
|
||
#ifndef __AFXTEMPL_H__
|
||
#include <afxtempl.h>
|
||
#define __AFXTEMPL_H_H
|
||
#endif
|
||
|
||
#include "OXDllExt.h"
|
||
|
||
// v9.3 - update 03 - 64bit - included for OXTPARAM
|
||
#include "UTB64Bit.h"
|
||
|
||
// for drag and drop support
|
||
#include "OXDragDropSupport.h"
|
||
#include "OXMainRes.h"
|
||
#include "OXToolTipCtrl.h"
|
||
|
||
//////////////////////////////////////////////////////////
|
||
|
||
|
||
|
||
typedef struct _tagNMBMCUSTOMIZE
|
||
{
|
||
NMHDR nmhdr;
|
||
UINT nCustomizeEventID;
|
||
LPARAM lParam;
|
||
} NMBMCUSTOMIZE;
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
// ID of the expansion item
|
||
#ifndef ID_OX_SHOWALLITEMS
|
||
#define ID_OX_SHOWALLITEMS 0x0000ff56
|
||
#endif // ID_OX_SHOWALLITEMS
|
||
|
||
#ifndef ID_OXBITMAPMENU_SEPARATOR_HEIGHT
|
||
#define ID_OXBITMAPMENU_SEPARATOR_HEIGHT 8
|
||
#endif // ID_OXBITMAPMENU_SEPARATOR_HEIGHT
|
||
|
||
#ifndef ID_OXBITMAPMENUPOPUPWND_DEFAULT_WIDTH
|
||
#define ID_OXBITMAPMENUPOPUPWND_DEFAULT_WIDTH 50
|
||
#endif // ID_OXBITMAPMENUPOPUPWND_DEFAULT_WIDTH
|
||
#ifndef ID_OXBITMAPMENUPOPUPWND_DEFAULT_HEIGHT
|
||
#define ID_OXBITMAPMENUPOPUPWND_DEFAULT_HEIGHT 18
|
||
#endif // ID_OXBITMAPMENUPOPUPWND_DEFAULT_HEIGHT
|
||
|
||
#ifndef IDT_OXCHECKFORDRAGDROPEVENT
|
||
#define IDT_OXCHECKFORDRAGDROPEVENT 412
|
||
#endif // IDT_OXCHECKFORDRAGDROPEVENT
|
||
#ifndef ID_OXCHECKFORDRAGDROPEVENT_DELAY
|
||
#define ID_OXCHECKFORDRAGDROPEVENT_DELAY 200
|
||
#endif // ID_OXCHECKFORDRAGDROPEVENT_DELAY
|
||
|
||
|
||
#ifndef OXODS_HIDDEN
|
||
#define OXODS_HIDDEN 0x1000
|
||
#endif // OXODS_HIDDEN
|
||
#ifndef OXODS_HIDDENFIRST
|
||
#define OXODS_HIDDENFIRST 0x2000
|
||
#endif // OXODS_HIDDENFIRST
|
||
#ifndef OXODS_HIDDENLAST
|
||
#define OXODS_HIDDENLAST 0x4000
|
||
#endif // OXODS_HIDDENLAST
|
||
|
||
class COXImageInfo;
|
||
class COXItemInfo;
|
||
class COXBitmapMenuOrganizer;
|
||
class COXMenuSkin;
|
||
class COXShadowedItemWnd;
|
||
class COXCoolToolBar;
|
||
|
||
struct OXDIMENSIONCONSTANTS
|
||
{
|
||
// The gap between left edge of menu item and bitmap in pixels
|
||
int m_nGapLeftBitmap;
|
||
// The gap between the right edge of the bitmap and the end of the icon area (XP skin only)
|
||
int m_nGapRightBitmap;
|
||
// The gap between bitmap and menu text in pixels
|
||
int m_nGapBitmapText;
|
||
// The gap between menu text and accelerator
|
||
int m_nGapTextAcclrtr;
|
||
// The gap between accelerator and right edge of menu item
|
||
int m_nGapAcclrtrRight;
|
||
// Extra vertical space on top and bottom of text in pixels
|
||
int m_nGapVertText;
|
||
// --- Extra vertical space on top and bottom of bitmap in pixels
|
||
int m_nGapVertBitmap;
|
||
// Height of the menu separator
|
||
int m_nSeparatorHeight;
|
||
// Minimum width of the bitmap
|
||
int m_nMinBitmapWidth;
|
||
// Gap between two menu items
|
||
int m_nGapMenuItems;
|
||
};
|
||
|
||
typedef CArray<COLORREF, COLORREF> OXSHADOWARRAY;
|
||
|
||
struct OXPOPUPWND
|
||
{
|
||
OXPOPUPWND(HWND hWindow)
|
||
{
|
||
hWnd = hWindow;
|
||
arPixels.SetSize(0, 1024);
|
||
};
|
||
HWND hWnd;
|
||
OXSHADOWARRAY arPixels;
|
||
};
|
||
|
||
class COXPopupWndStack : public CTypedPtrList<CPtrList, OXPOPUPWND*>
|
||
{
|
||
public:
|
||
void Push(HWND hWnd) { AddHead(new OXPOPUPWND(hWnd)); };
|
||
HWND Pop()
|
||
{
|
||
if (IsEmpty())
|
||
return NULL;
|
||
return GetHead()->hWnd;
|
||
};
|
||
|
||
// Remove the OXPOPUPWND from the stack
|
||
void Remove(HWND hWnd)
|
||
{
|
||
POSITION pos = GetHeadPosition();
|
||
while (pos != NULL)
|
||
{
|
||
OXPOPUPWND* pPW = GetAt(pos);
|
||
if (pPW->hWnd == hWnd)
|
||
{
|
||
RemoveAt(pos);
|
||
delete pPW;
|
||
break;
|
||
}
|
||
GetNext(pos);
|
||
}
|
||
};
|
||
|
||
// Returns the shadow array of the given window
|
||
OXSHADOWARRAY* GetShadowArray(HWND hWnd)
|
||
{
|
||
POSITION pos = GetHeadPosition();
|
||
while (pos != NULL)
|
||
{
|
||
OXPOPUPWND* pPW = GetNext(pos);
|
||
if (pPW->hWnd == hWnd)
|
||
return &pPW->arPixels;
|
||
}
|
||
return NULL;
|
||
}
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// COXShadowedItemWnd window
|
||
|
||
class COXShadowedItemWnd : public CWnd
|
||
{
|
||
friend class COXMenuSkinClassic;
|
||
friend class COXMenuSkinXP;
|
||
friend class COXMenuSkin2003;
|
||
|
||
// Construction
|
||
public:
|
||
COXShadowedItemWnd(COXCoolToolBar* pCoolToolBar, int iMenuItem, UINT nFlags);
|
||
|
||
// Attributes
|
||
public:
|
||
|
||
// Operations
|
||
public:
|
||
|
||
// Overrides
|
||
// ClassWizard generated virtual function overrides
|
||
//{{AFX_VIRTUAL(COXShadowedItemWnd)
|
||
//}}AFX_VIRTUAL
|
||
|
||
// Implementation
|
||
public:
|
||
virtual ~COXShadowedItemWnd();
|
||
|
||
// Generated message map functions
|
||
protected:
|
||
//{{AFX_MSG(COXShadowedItemWnd)
|
||
afx_msg void OnPaint();
|
||
//}}AFX_MSG
|
||
DECLARE_MESSAGE_MAP()
|
||
private:
|
||
COXCoolToolBar* m_pCoolToolbar;
|
||
int m_iMenuItem;
|
||
UINT m_nPosFlags;
|
||
|
||
};
|
||
|
||
// Flags to indicate the ralative position of the popup menu from the selected item
|
||
#define OX_TPM_BOTTOM 0x1 // the menu is displayed on the bottom of the selected item
|
||
#define OX_TPM_RIGHT 0x2
|
||
#define OX_TPM_LEFT 0x4
|
||
#define OX_TPM_TOP 0x8
|
||
|
||
class OX_CLASS_DECL COXBitmapMenu : public CMenu
|
||
{
|
||
friend class COXBitmapMenuOrganizer;
|
||
friend class COXMenuSkinClassic;
|
||
friend class COXMenuSkinXP;
|
||
friend class COXMenuSkin2003;
|
||
friend class COXMenuBar;
|
||
friend class COXBitmapMenuPopupWnd;
|
||
friend class COXShadowedItemWnd;
|
||
|
||
DECLARE_DYNAMIC(COXBitmapMenu)
|
||
|
||
//Data members --------------------------------------------------------
|
||
|
||
protected:
|
||
// map of accelerator keys
|
||
CMap<TCHAR, TCHAR, int, int> m_KeyAccessMap;
|
||
// holds the largest width of all the bitmaps in the menu
|
||
int m_nBitmapExtent;
|
||
// holds the height of the text
|
||
int m_nTextHeight;
|
||
// holds the largest width of the all the accelerator texts of menu items
|
||
int m_nAcceleratorExtent;
|
||
// holds the largest width of the texts of menu items
|
||
int m_nStringExtent;
|
||
// Maintains a list of item infos for cleaning purpose
|
||
// while destructing the object
|
||
CList<COXItemInfo*, COXItemInfo*> m_ItemInfoList;
|
||
|
||
|
||
// flag that specifies that menu supports customization
|
||
BOOL m_bCutomizable;
|
||
// index of the menu item being currently customized
|
||
int m_nCustomizedItemIndex;
|
||
// flag that specifies that the menu is in the customization mode
|
||
BOOL m_bInCutomizationMode;
|
||
// recipient of customization related notifications
|
||
HWND m_hWndCustomizeOrganizer;
|
||
|
||
|
||
// default COleDropSource for drag'n'drop operation
|
||
COXSHBDropSource m_oleDropSource;
|
||
// default COleDropTarget for drag'n'drop operation
|
||
COXSHBDropTarget m_oleDropTarget;
|
||
// flag that specifies whether we launched drag'n'drop operation or not
|
||
BOOL m_bDragDropOwner;
|
||
// flag that specifies if any drag and drop operation is undergoing
|
||
BOOL m_bDragDropOperation;
|
||
|
||
// popup window that displays the menu in customization mode
|
||
class COXBitmapMenuPopupWnd* m_pPopupWnd;
|
||
|
||
// index of the item before which the insertion mark is drawn
|
||
int m_nInsertMarkIndex;
|
||
|
||
// index of the dragged item
|
||
int m_nDraggedItemIndex;
|
||
|
||
// The rectangle of the toolbar or menubar drop down button which is
|
||
// responsible for displaying the menu. This rectangle is in screen coordinates.
|
||
CRect m_rectDropDownItem;
|
||
|
||
static LRESULT CALLBACK PopupWndProc(HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam);
|
||
|
||
COXPopupWndStack m_PopupWndStack; // a stack of all popup container windows
|
||
|
||
COXToolTipCtrl m_ToolTipCtrl;
|
||
|
||
private:
|
||
BOOL IsPopupItem(UINT nItemID);
|
||
static BOOL RegisterWindowClass(HINSTANCE hInstance);
|
||
static CSize GetPopupMenuSize(CMenu* pMenu);
|
||
static void DeterminePosition(CMenu* pMenu, LPCRECT lpItemRect, DWORD dwStyle, CPoint& ptTopLeft, UINT& nFlags, UINT& nPosFlags);
|
||
static COXMenuSkin* m_pMenuSkin;
|
||
static COXMenuSkin* COXBitmapMenu::GetMenuSkin();
|
||
|
||
//Member functions-----------------------------------------------------------------------
|
||
public:
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns :
|
||
// --- Effect : Object Constructions and defaults are initialised
|
||
COXBitmapMenu();
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns :
|
||
// --- Effect : Cleanup and Object Destruction
|
||
virtual ~COXBitmapMenu();
|
||
|
||
|
||
// --- In : lpDrawItemStruct - A pointer to a DRAWITEMSTRUCT
|
||
// containing information about
|
||
// the item to draw.
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : This function is called by the MFC framework when a visual
|
||
// aspect of the menu has changed. If you override this function
|
||
// to implement drawing of the menu you must restore all GDI
|
||
// object selected for the display context supplied in
|
||
// lpDrawItemStruct before the member function exits
|
||
virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
|
||
|
||
// --- In : lpMeasureItemStruct - A pointer to a MEASUREITEMSTRUCT structure
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : This function is called by the framework to determine menu
|
||
// dimensions the menu is created
|
||
virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
|
||
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Calculates the largest extents of bitmaps, menu texts,
|
||
// and accelerator texts
|
||
void CalcExtents();
|
||
|
||
|
||
// --- In : ppt - pointer to POINT structure that defines the point
|
||
// to test in client coordinates of the menu popup
|
||
// window
|
||
// --- Out : pbBefore - pointer to BOOL variable that will be set to
|
||
// TRUE if specified point is located over the top
|
||
// part of found menu item; othrwise it will be set
|
||
// to FALSE
|
||
// --- Returns: The index of the found menu item
|
||
// --- Effect : Finds menu item that is located under the specified point
|
||
int HitTest(LPPOINT ppt, BOOL* pbBefore=NULL);
|
||
|
||
|
||
// --- In : bCustomizable - if TRUE the menu ca be customized
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Sets the flag that specifies whether the menu can be
|
||
// customized or not
|
||
inline void SetCustomizable(BOOL bCustomizable) { m_bCutomizable=bCustomizable; }
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: TRUE if the menu can be customized; otherwise FALSE
|
||
// --- Effect: Retrieves the flag that specifies whether the menu can be
|
||
// customized or not
|
||
virtual BOOL IsCustomizable() const { return m_bCutomizable; }
|
||
|
||
|
||
// --- In : bInCutomizationMode - if TRUE the menu will be set in to
|
||
// customization mode
|
||
// hWndCustomizeOrganizer - handle to window that will be a
|
||
// recipient of customization related
|
||
// notifications
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Sets the menu in to customization/normal mode
|
||
inline void SetCutomizationMode(BOOL bInCutomizationMode,
|
||
HWND hWndCustomizeOrganizer=NULL)
|
||
{
|
||
if(bInCutomizationMode && !IsCustomizable())
|
||
SetCustomizable(TRUE);
|
||
if(!bInCutomizationMode)
|
||
SetCustomizedItem(-1);
|
||
else
|
||
m_hWndCustomizeOrganizer=hWndCustomizeOrganizer;
|
||
m_bInCutomizationMode=bInCutomizationMode;
|
||
}
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: TRUE if the menu is in customization mode; FALSE if it is in
|
||
// normal mode
|
||
// --- Effect: Retrieves the flag that specifies whether the menu is in
|
||
// customization or normal mode
|
||
inline BOOL IsInCustomizationMode() const { return m_bInCutomizationMode; }
|
||
|
||
|
||
// --- In : nIndex - menu item index to be set as customized
|
||
// --- Out :
|
||
// --- Returns: The index of previous customized menu item. -1 if there were
|
||
// no customized menu item before
|
||
// --- Effect : Sets customized menu item. Specify -1 as a parameter in order
|
||
// to reset customized menu item
|
||
int SetCustomizedItem(int nIndex);
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: The index of the customized menu item. -1 if there is no
|
||
// customized menu item
|
||
// --- Effect : Retrieves customized menu item
|
||
inline int GetCustomizedItem() const { return m_nCustomizedItemIndex; }
|
||
|
||
// --- In : nIndex - menu item index to test
|
||
// --- Out :
|
||
// --- Returns: TRUE if specified menu item is customized; otherwise FALSE
|
||
// --- Effect : Retrieves the flag that specifies if given item is customized
|
||
// one or not
|
||
inline BOOL IsItemCustomized(int nIndex) const
|
||
{
|
||
return (nIndex==m_nCustomizedItemIndex);
|
||
}
|
||
|
||
|
||
// --- In : nIndex - menu item index before which the insert mark
|
||
// will be set
|
||
// --- Out :
|
||
// --- Returns: The insert mark previous position. -1 if there were no
|
||
// insert mark set before
|
||
// --- Effect : Sets insert mark at specified position. Specify -1 as a
|
||
// parameter in order to reset insert mark position
|
||
int SetInsertMark(int nItemIndex);
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: The insert mark position. -1 if there is no insert mark set
|
||
// --- Effect : Retrives insert mark position
|
||
inline int GetInsertMark() const { return m_nInsertMarkIndex; }
|
||
|
||
|
||
// --- In : nIndex - menu item index to be set as dragged
|
||
// --- Out :
|
||
// --- Returns: The index of previous dragged menu item. -1 if there were
|
||
// no dragged menu item before
|
||
// --- Effect : Sets dragged menu item. Specify -1 as a parameter in order
|
||
// to reset dragged menu item
|
||
inline void SetDraggedItem(int nIndex) { m_nDraggedItemIndex=nIndex; }
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: The index of the dragged menu item. -1 if there is no
|
||
// dragged menu item
|
||
// --- Effect : Retrieves dragged menu item
|
||
inline int GetDraggedItem() const { return m_nDraggedItemIndex; }
|
||
|
||
// --- In : nIndex - menu item index to test
|
||
// --- Out :
|
||
// --- Returns: TRUE if specified menu item is dragged; otherwise FALSE
|
||
// --- Effect : Retrieves the flag that specifies if given item is dragged
|
||
// one or not
|
||
inline BOOL IsItemDragged(int nIndex) const
|
||
{
|
||
return (nIndex==m_nDraggedItemIndex);
|
||
}
|
||
|
||
|
||
// --- In : nIndex - menu item index to display customize menu for
|
||
// point - screen coordinates of the Top/Left point at which
|
||
// the context menu should be displayed
|
||
// --- Out :
|
||
// --- Returns: TRUE if context menu was successfully created and displayed;
|
||
// otherwise FALSE
|
||
// --- Effect : Display context menu with customization commands for the
|
||
// specified menu item
|
||
virtual BOOL DisplayCustomizeItemContextMenu(int nItemIndex, CPoint point);
|
||
|
||
|
||
// --- In : pWndOwner - pointer to a window that will be assigned as
|
||
// an owner of returned COleDropSource object
|
||
// --- Out :
|
||
// --- Returns: A pointer to internal COleDropSource object
|
||
// --- Effect : Retrieves a pointer to internal COleDropSource object that will
|
||
// allow this object to handle drag'n'drop operation
|
||
virtual COleDropSource* GetDropSource(CWnd* pWndOwner)
|
||
{
|
||
ASSERT(pWndOwner!=NULL);
|
||
// owner window (recipient window) must exist at that moment
|
||
ASSERT(::IsWindow(pWndOwner->GetSafeHwnd()));
|
||
m_oleDropSource.SetOwner(pWndOwner);
|
||
return &m_oleDropSource;
|
||
}
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: A pointer to internal COleDropTarget object
|
||
// --- Effect : Retrieves a pointer to internal COleDropTarget object that will
|
||
// allow this object to handle drag'n'drop operation
|
||
virtual COleDropTarget* GetDropTarget() { return &m_oleDropTarget; }
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: TRUE if this object has started current drag'n'drop operation;
|
||
// otherwise FALSE
|
||
// --- Effect : Retrieves the flag that specifies whether this object has
|
||
// started current drag'n'drop operation
|
||
inline BOOL IsDragDropOwner() const { return m_bDragDropOwner; }
|
||
|
||
|
||
// --- In : pPopupWnd - a pointer to COXBitmapMenuPopupWnd object that
|
||
// will be used to display the menu in customization
|
||
// mode
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Sets a pointer to COXBitmapMenuPopupWnd object that will be used
|
||
// to display the menu in customization mode
|
||
inline void SetPopupWnd(COXBitmapMenuPopupWnd* pPopupWnd)
|
||
{
|
||
m_pPopupWnd=pPopupWnd;
|
||
}
|
||
|
||
// --- In : pPopupWnd - a pointer to COXBitmapMenuPopupWnd object that
|
||
// will be used to display the menu in customization
|
||
// mode
|
||
// --- Out :
|
||
// --- Returns: A pointer to COXBitmapMenuPopupWnd object that will be used to
|
||
// display the menu in customization mode
|
||
// --- Effect : Retrieves a pointer to COXBitmapMenuPopupWnd object that will be used
|
||
// to display the menu in customization mode
|
||
virtual COXBitmapMenuPopupWnd* GetPopupWnd() const { return m_pPopupWnd; }
|
||
|
||
|
||
// --- In : nIndex - index of the menu item that is about to become the
|
||
// dragged one
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect: Initializes drag'n'drop operation
|
||
virtual void OnBeginDragDrop(int nIndex);
|
||
|
||
|
||
// --- In : rgbFace - base color
|
||
// rgbHilight - hilight color
|
||
// --- Out :
|
||
// --- Returns: A handle to created brush object that combines base and highlight
|
||
// colors in a specific way
|
||
// --- Effect: Creates new brush object for drawing routines (allows to draw
|
||
// the background in the way similar to drawing the background
|
||
// of pressed toolbar button). Caller is responsible for deleting
|
||
// thie returned brush
|
||
static HBRUSH HBrushDitherCreate(COLORREF rgbFace, COLORREF rgbHilight);
|
||
|
||
BOOL TrackPopupMenu(COXCoolToolBar* pCoolToolBar, CWnd* pWnd, LPCRECT lpRect = NULL);
|
||
|
||
// --- Effect: This method should be called by a CMDMSG handler in the main app,
|
||
// and it's job is to handle menu buttons for restore/close/minimize in an MDI app
|
||
static BOOL HandleMDICommandMessage(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo);
|
||
|
||
private:
|
||
static void RestoreMDI();
|
||
static void CloseMDI();
|
||
static void MinimizeMDI();
|
||
|
||
protected:
|
||
static WNDPROC m_origWndProc;
|
||
// calculates rectangles for displaying item's image, text and accelerator text
|
||
virtual void DistributeSpace(UINT nState, COXImageInfo* pImageInfo,
|
||
CRect itemRect, CRect& buttonRect, CRect& imageRect, CRect& text1Rect,
|
||
CRect& text2Rect);
|
||
// draws the background of menu item
|
||
virtual void DrawBackground(CDC* pDC, UINT nState, COXImageInfo* pImageInfo,
|
||
CRect itemRect, CRect buttonRect);
|
||
// draws the button that frames menu item image
|
||
virtual void DrawButton(CDC* pDC, UINT nState, COXImageInfo* pImageInfo,
|
||
CRect buttonRect);
|
||
// draws menu item image
|
||
virtual void DrawImage(CDC* pDC, UINT nState, COXImageInfo* pImageInfo,
|
||
CRect imageRect);
|
||
// draws menu item text
|
||
virtual void DrawText(CDC* pDC, UINT nState, CString sText, CRect text1Rect,
|
||
CRect text2Rect);
|
||
// draws separator menu item
|
||
virtual void DrawSeparator(CDC* pDC, CRect itemRect);
|
||
// draws customized menu item
|
||
virtual void DrawCustomized(CDC* pDC, CRect itemRect);
|
||
// draws insert mark
|
||
virtual void DrawInsertMark(CDC* pDC, CRect itemRect, BOOL bBefore);
|
||
// draws submenu item
|
||
virtual void DrawSubmenuItem(CDC* pDC, UINT nState, CString sText,
|
||
COXImageInfo* pImageInfo, CRect itemRect, CRect buttonRect,
|
||
CRect text1Rect, CRect text2Rect);
|
||
// draws ezpansion item
|
||
virtual void DrawExpansionItem(CDC* pDC, CRect itemRect, UINT nState);
|
||
|
||
// Saves new created COXItemInfo object in the internal array
|
||
void AddItemInfo(COXItemInfo* pItemInfo);
|
||
|
||
// handle update routines for the menu commands
|
||
void OnUpdateCmdUI(CWnd* pWnd, UINT nIndex, BOOL bSysMenu);
|
||
|
||
// sends customization related notifications
|
||
LRESULT SendCustomizeNotification(UINT nCustomizeCmdID);
|
||
|
||
// update the contents of the displayed menu
|
||
void UpdateContents();
|
||
|
||
public:
|
||
// drag and drop support
|
||
virtual LONG OnDragEnter(WPARAM wParam, LPARAM lParam);
|
||
virtual LONG OnDragOver(WPARAM wParam, LPARAM lParam);
|
||
virtual LONG OnDragLeave(WPARAM wParam, LPARAM lParam);
|
||
virtual LONG OnDrop(WPARAM wParam, LPARAM lParam);
|
||
|
||
|
||
// --- In : lpData - reference to a pointer of data that contains
|
||
// item info in specific drag'n'drop format
|
||
// hMenu - handle to a menu where dropped item will be
|
||
// inserted
|
||
// nItemIndex - position at which dropped item will be inserted
|
||
//
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect: Retrieves item info from dropped data and insert it at specified
|
||
// position in specified menu
|
||
virtual void RetrieveDragDropMenuItem(BYTE*& lpData, HMENU hMenu, int nItemIndex);
|
||
|
||
// advanced customization commands handlers
|
||
virtual void OnCustBMDelete();
|
||
virtual void OnCustBMAppearance();
|
||
virtual void OnCustBMSeparatorBefore();
|
||
virtual void OnCustBMSeparatorAfter();
|
||
virtual void OnCustBMRecentlyUsed();
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
class OX_CLASS_DECL COXBitmapMenuPopupWnd : public CWnd
|
||
{
|
||
friend class COXMenuSkinClassic;
|
||
friend class COXMenuSkinXP;
|
||
|
||
DECLARE_DYNAMIC(COXBitmapMenuPopupWnd)
|
||
|
||
//Data members --------------------------------------------------------
|
||
public:
|
||
|
||
protected:
|
||
COXBitmapMenu* m_pBitmapMenu;
|
||
|
||
CRect m_rectWindow;
|
||
CArray<CRect,CRect&> m_arrItemRects;
|
||
|
||
CFont m_fontMenu;
|
||
|
||
INT_PTR m_nCheckForDragDropEventTimerID;
|
||
|
||
//Member functions-----------------------------------------------------------------------
|
||
public:
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Constructs the object
|
||
COXBitmapMenuPopupWnd();
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Destructs the object
|
||
virtual ~COXBitmapMenuPopupWnd();
|
||
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns: pointer to associated bitmap menu object
|
||
// --- Effect : retrieves the associated bitmap menu object
|
||
virtual COXBitmapMenu* GetBitmapMenu() const { return m_pBitmapMenu; }
|
||
|
||
|
||
// --- In : pMenu - pointer to the popup bitmap menu to be displayed
|
||
// nFlags - Specifies a screen-position flag. It can be
|
||
// one of the following:
|
||
//
|
||
// TPM_CENTERALIGN Centers the pop-up menu horizontally
|
||
// relative to the coordinate specified
|
||
// by x.
|
||
// TPM_LEFTALIGN Positions the pop-up menu so that its
|
||
// left side is aligned with the
|
||
// coordinate specified by x.
|
||
// TPM_RIGHTALIGN Positions the pop-up menu so that its
|
||
// right side is aligned with the
|
||
// coordinate specified by x.
|
||
//
|
||
// x - Specifies the horizontal position in screen
|
||
// coordinates of the pop-up menu. Depending on the
|
||
// value of the nFlags parameter, the menu can be
|
||
// left-aligned, right-aligned, or centered relative
|
||
// to this position
|
||
// y - Specifies the vertical position in screen
|
||
// coordinates of the top of the menu on the screen
|
||
// pWnd - Identifies the window that owns the pop-up menu.
|
||
// --- Out :
|
||
// --- Returns: TRUE if the function is successful; otherwise FALSE
|
||
// --- Effect : Displays a floating pop-up menu at the specified location and
|
||
// tracks the selection of items on the pop-up menu. A floating
|
||
// pop-up menu can appear anywhere on the screen
|
||
virtual BOOL TrackPopupMenu(COXBitmapMenu* pMenu, UINT nFlags,
|
||
int x, int y, CWnd* pWnd);
|
||
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Hides the popup window and reset all internal data
|
||
virtual void ResetPopupMenu();
|
||
|
||
|
||
// --- In :
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Called by bitmap menu object in order to notify that
|
||
// the contents of the menu have been changed
|
||
virtual void OnMenuChanged();
|
||
|
||
|
||
// --- In : nIndex - index of the item in the associated menu that
|
||
// must be redrawn
|
||
// --- Out :
|
||
// --- Returns:
|
||
// --- Effect : Redraws the specified menu item
|
||
void RedrawItem(int nIndex);
|
||
|
||
|
||
// --- In : nIndex - index of the item in the associated menu which
|
||
// rectangle in client coordinates is being retrieved
|
||
// --- Out :
|
||
// --- Returns: rectangle taken by the specified menu item
|
||
// --- Effect : Retrieves the rectangle taken by the specified menu item
|
||
inline CRect GetItemRect(int nIndex) const
|
||
{
|
||
ASSERT(nIndex>=0 && nIndex<m_arrItemRects.GetSize());
|
||
return m_arrItemRects[nIndex];
|
||
}
|
||
|
||
|
||
protected:
|
||
// --- In : nFlags - Specifies a screen-position flag. It can be one of the
|
||
// following:
|
||
//
|
||
// TPM_CENTERALIGN Centers the pop-up menu horizontally
|
||
// relative to the coordinate specified
|
||
// by x.
|
||
// TPM_LEFTALIGN Positions the pop-up menu so that its
|
||
// left side is aligned with the
|
||
// coordinate specified by x.
|
||
// TPM_RIGHTALIGN Positions the pop-up menu so that its
|
||
// right side is aligned with the
|
||
// coordinate specified by x.
|
||
//
|
||
// x - Specifies the horizontal position in screen
|
||
// coordinates of the pop-up menu. Depending on the
|
||
// value of the nFlags parameter, the menu can be
|
||
// left-aligned, right-aligned, or centered relative
|
||
// to this position
|
||
// y - Specifies the vertical position in screen
|
||
// coordinates of the top of the menu on the screen
|
||
// --- Out :
|
||
// --- Returns: TRUE if the function is successful; otherwise FALSE
|
||
// --- Effect : Displays a floating pop-up menu at the specified location and
|
||
// tracks the selection of items on the pop-up menu. A floating
|
||
// pop-up menu can appear anywhere on the screen
|
||
virtual BOOL CalcLayout(UINT nFlags, int x, int y);
|
||
|
||
|
||
protected:
|
||
void UpdateMenuMetrics();
|
||
|
||
// Generated message map functions
|
||
protected:
|
||
//{{AFX_MSG(COXBitmapMenuPopupWnd)
|
||
afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
|
||
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
|
||
afx_msg void OnMButtonDown(UINT nFlags, CPoint point);
|
||
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
|
||
afx_msg void OnPaint();
|
||
afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
|
||
afx_msg void OnSettingChange(UINT uFlags, LPCTSTR lpszSection);
|
||
// v9.3 - update 03 - 64-bit - using OXTPARAM here - see UTB64Bit.h
|
||
afx_msg void OnTimer(OXTPARAM nIDEvent);
|
||
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
|
||
afx_msg void OnNcPaint();
|
||
//}}AFX_MSG
|
||
|
||
// drag and drop support
|
||
// v9.3 - update 03 - 64-bit - return values were declared as LONG - changed to LRESULT
|
||
virtual LRESULT OnDragEnter(WPARAM wParam, LPARAM lParam);
|
||
virtual LRESULT OnDragOver(WPARAM wParam, LPARAM lParam);
|
||
virtual LRESULT OnDragLeave(WPARAM wParam, LPARAM lParam);
|
||
virtual LRESULT OnDrop(WPARAM wParam, LPARAM lParam);
|
||
|
||
// advanced customization commands handlers
|
||
afx_msg void OnCustBMDelete();
|
||
afx_msg void OnCustBMAppearance();
|
||
afx_msg void OnCustBMSeparatorBefore();
|
||
afx_msg void OnCustBMSeparatorAfter();
|
||
afx_msg void OnCustBMRecentlyUsed();
|
||
|
||
DECLARE_MESSAGE_MAP()
|
||
};
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
|
||
#endif
|