// XTPShortcutBar.h interface for the CXTPShortcutBar class.
//
// This file is a part of the XTREME SHORTCUTBAR MFC class library.
// (c)1998-2012 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////
//{{AFX_CODEJOCK_PRIVATE
#if !defined(__XTPSHORTCUTBAR_H__)
#define __XTPSHORTCUTBAR_H__
//}}AFX_CODEJOCK_PRIVATE
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CXTPShortcutBarAnimation;
class CXTPShortcutBarPopup;
class CXTPImageManagerIcon;
//-----------------------------------------------------------------------
// Summary:
// XTP_SBN_SELECTION_CHANGED is used to indicate that the selection
// has changed in the shortcut bar.
// Remarks:
// XTP_SBN_SELECTION_CHANGED is sent in the XTPWM_SHORTCUTBAR_NOTIFY
// message to the owner window when the selection has changed.
//
// The selection changed when a user clicks on a shortcut bar item or
// the items are navigated with the arrow keys.
// Example:
// See example of XTPWM_SHORTCUTBAR_NOTIFY
// See Also:
// XTPWM_SHORTCUTBAR_NOTIFY, XTP_SBN_RCLICK
//-----------------------------------------------------------------------
const UINT XTP_SBN_SELECTION_CHANGING = 1;
//-----------------------------------------------------------------------
// Summary:
// XTP_SBN_SELECTION_CHANGING is used to indicate that value for the selection
// is currently changing.
// Remarks:
// XTP_SBN_SELECTION_CHANGING is sent in the XTPWM_SHORTCUTBAR_NOTIFY
// message to the owner window when the selection is in the process of changing.
//
// The selection changed when a user clicks on a shortcut bar item or
// the items are navigated with the arrow keys.
// See Also:
// XTPWM_SHORTCUTBAR_NOTIFY, XTP_SBN_RCLICK
//-----------------------------------------------------------------------
const UINT XTP_SBN_SELECTION_CHANGED = 3;
//-----------------------------------------------------------------------
// Summary:
// XTP_SBN_RCLICK is used to indicate that the user has pressed the
// right mouse button on a shortcut bar item.
// Remarks:
// XTP_SBN_RCLICK is sent in the XTPWM_SHORTCUTBAR_NOTIFY message to the
// owner window when the user has right clicked on a shortcut bar item.
// Example:
// See example of XTPWM_SHORTCUTBAR_NOTIFY
// See Also:
// XTPWM_SHORTCUTBAR_NOTIFY, XTP_SBN_SELECTION_CHANGING
//-----------------------------------------------------------------------
const UINT XTP_SBN_RCLICK = 2;
//-----------------------------------------------------------------------
// Summary:
// XTP_SBN_MINIMIZEBUTTONCLICKED is used to indicate that the user has pressed the
// minimize button inside Pane caption
// Remarks:
// XTP_SBN_MINIMIZEBUTTONCLICKED is sent in the XTPWM_SHORTCUTBAR_NOTIFY message to the
// owner window when the user has clicked minimize button
// Example:
// See example of XTPWM_SHORTCUTBAR_NOTIFY
// See Also:
// XTPWM_SHORTCUTBAR_NOTIFY, XTP_SBN_SELECTION_CHANGING, CXTPShortcutBar::ShowMinimizeButton
//-----------------------------------------------------------------------
const UINT XTP_SBN_MINIMIZEBUTTONCLICKED = 4;
//-----------------------------------------------------------------------
// Summary:
// The XTPWM_SHORTCUTBAR_NOTIFY message is sent to the CXTPShortcutBar owner window
// whenever an action occurs within the CXTPShortcutBar
// Parameters:
// nAction - Value of wParam specifies a ShortcutBar value that indicates the user's
// request.
// pItem - The value of lParam points to an CXTPShortcutBarItem object that contains information for the
// specified item. This pointer should <b>never</b> be NULL.
// Remarks:
// nAction parameter can be one of the following values:
// * <b>XTP_SBN_SELECTION_CHANGING</b> Indicates the selection has changed in the shortcut bar.
// * <b>XTP_SBN_RCLICK</b> Indicates the user pressed the right mouse button on the shortcut bar item.
//
// Returns:
// If the application is to process this message, the return value should be TRUE, otherwise the
// return value is FALSE.
// Example:
// Here is an example of how an application would process the XTPWM_SHORTCUTBAR_NOTIFY
// message.
// <code>
//
// BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
// //{{AFX_MSG_MAP(CMainFrame)
// ON_MESSAGE(XTPWM_SHORTCUTBAR_NOTIFY, OnShortcutBarNotify)
// //}}AFX_MSG_MAP
// END_MESSAGE_MAP()
//
// LRESULT CMainFrame::OnShortcutBarNotify(WPARAM wParam, LPARAM lParam)
// {
// switch (wParam)
// {
// case XTP_SBN_SELECTION_CHANGING:
// {
// CXTPShortcutBarItem* pItem = (CXTPShortcutBarItem*)lParam;
// TRACE(_T("Selection Changing. Item.Caption = %s\n"), pItem->GetCaption());
//
// // TODO: You can return -1 to ignore changing
//
// }
// return TRUE;
// case XTP_SBN_RCLICK:
// {
// CPoint point(lParam);
// CXTPShortcutBarItem* pItem = m_wndShortcutBar.HitTest(point);
// if (pItem)
// {
// TRACE(_T("RClick. Item.ID = %i\n"), pItem->GetID());
//
// CMenu mnu;
// mnu.LoadMenu(IDR_POPUP_MENU);
//
// m_wndShortcutBar.ClientToScreen(&point);
//
// CXTPCommandBars::TrackPopupMenu(mnu.GetSubMenu(0), 0, point.x, point.y, AfxGetMainWnd());
//
// }
// }
// return TRUE;
//
//
// }
// return 0;
// }
// </code>
// See Also:
// XTP_SBN_SELECTION_CHANGING, XTP_SBN_RCLICK, CXTPShortcutBar
//-----------------------------------------------------------------------
const UINT XTPWM_SHORTCUTBAR_NOTIFY = (WM_USER + 9190 + 1);
class CXTPShortcutBar;
class CXTPImageManager;
class CXTPToolTipContext;
//===========================================================================
// Summary:
// CXTPShortcutBarItem is the base class representing an item of the
// ShortcutBar Control.
//===========================================================================
class _XTP_EXT_CLASS CXTPShortcutBarItem : public CXTPCmdTarget
{
protected:
//-----------------------------------------------------------------------
// Summary:
// Constructs a CXTPShortcutBarItem object.
// Parameters:
// pShortcutBar - Points to the parent ShortcutBar class.
// nID - Identifier of the item.
// pWnd - Client window of the item
// pShortcutBar - Points to the parent ShortcutBar class.
//-----------------------------------------------------------------------
CXTPShortcutBarItem(CXTPShortcutBar* pShortcutBar, int nID, CWnd* pWnd); // <combine CXTPShortcutBarItem::CXTPShortcutBarItem@CXTPShortcutBar*>
public:
//-----------------------------------------------------------------------
// Summary:
// Call this method to set the identifier of the item.
// Parameters:
// nID - The new identifier of the item.
//-----------------------------------------------------------------------
void SetID(int nID);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get the identifier of the item.
// Returns:
// Identifier of the item.
//-----------------------------------------------------------------------
int GetID() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to set the icon's identifier.
// Parameters:
// nId - Icon's identifier to be set.
//-----------------------------------------------------------------------
void SetIconId(int nId);
//-----------------------------------------------------------------------
// Summary:
// Call this member to get the icon's identifier.
// Returns:
// An icon's identifier of the item.
//-----------------------------------------------------------------------
int GetIconId() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to set the caption of the item.
// Parameters:
// strCaption - The new caption of the item.
//-----------------------------------------------------------------------
void SetCaption(LPCTSTR strCaption);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get the caption of the item.
// Returns:
// A CString object containing the caption of the item.
//-----------------------------------------------------------------------
CString GetCaption() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to set the visibility state of the item.
// Parameters:
// bVisible - TRUE if the item is visible; otherwise FALSE.
//-----------------------------------------------------------------------
void SetVisible(BOOL bVisible);
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine if the item is visible.
// Returns:
// TRUE if the item is visible; otherwise FALSE.
//-----------------------------------------------------------------------
BOOL IsVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Associates ToolTip text with the item.
// Parameters:
// strTooltip - The ToolTip text to display when the mouse cursor is over the item.
//-----------------------------------------------------------------------
void SetTooltip(LPCTSTR strTooltip);
//-----------------------------------------------------------------------
// Summary:
// Retrieves the ToolTip text associated with the item.
// Returns:
// The ToolTip text for the item.
//-----------------------------------------------------------------------
CString GetTooltip() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine if the item is expanded.
// Returns:
// TRUE if the item is expanded; otherwise FALSE.
//-----------------------------------------------------------------------
BOOL IsExpanded() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine if the item is expand button.
// Returns:
// TRUE if the item is expand button; otherwise FALSE.
//-----------------------------------------------------------------------
BOOL IsItemExpandButton() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to get the parent ShortcutBar class.
// Returns:
// A Pointer to the parent CXTPShortcutBar class.
//-----------------------------------------------------------------------
CXTPShortcutBar* GetShortcutBar() const;
//-----------------------------------------------------------------------
// Summary:
// This method retrieves the dimensions of the rectangle that bounds the item.
// Returns:
// CRect object contains the bounding rectangle of the item.
//-----------------------------------------------------------------------
CRect GetItemRect() const;
//-----------------------------------------------------------------------
// Summary:
// This method sets the 32-bit value associated with the item.
// Parameters:
// dwData - Contains the new value to associate with the item.
//-----------------------------------------------------------------------
void SetItemData(DWORD_PTR dwData);
//-----------------------------------------------------------------------
// Summary:
// This method retrieves the application-supplied 32-bit value associated with the item
// Returns:
// The 32-bit value associated with the item
//-----------------------------------------------------------------------
DWORD_PTR GetItemData() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to retrieve the image of this shortcut bar item.
// Parameters:
// nWidth - Width of the icon to be retrieved. (CXTPImageManagerIcon
// can have multiple image sizes for the same item, the
// shortcut bar uses both 16x16 and 24x24 images depending on
// if the item is displayed in the extended shortcut list).
// If a 16x16 icon is to be retrieved, then pass in 16 for
// the width.
// Returns:
// A pointer the CXTPImageManagerIcon object for this shortcut bar
// item.
//-----------------------------------------------------------------------
CXTPImageManagerIcon* GetImage(int nWidth) const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine is the ShortcutBarItem is hidden.
// An item is hidden when there are more items then can be displayed
// in the bottom shortcut bar. As the shortcut bar is expanded, items
// that were hidden will become visible as more items are added to the
// expanded shortcut bar.
// Returns:
// TRUE is the ShortcutBarItem is hidden, otherwise FALSE
//-----------------------------------------------------------------------
BOOL IsHidden() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to determine if the item is currently selected.
// Note that multiple items can be selected at one time, but only one
// can have focus.
// Returns:
// TRUE if the item is currently selected.
//-----------------------------------------------------------------------
BOOL IsSelected() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to select this item. Multiple items can have
// focus if CXTPShortcutBar::m_bSingleSelection is FALSE.
// Parameters:
// bSelected - TRUE if the item will be selected, FALSE to no longer
// select the item.
//-----------------------------------------------------------------------
void SetSelected(BOOL bSelected);
//-----------------------------------------------------------------------
// Summary:
// Call this member to get child window of the item.
// Returns:
// CWnd pointer to child window
//-----------------------------------------------------------------------
CWnd* GetClientWindow() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to set child window that will be visible
// in client part of the shortcutbar when item is selected.
// Parameters:
// pWnd - New child window to be set.
//-----------------------------------------------------------------------
void SetClientWindow(CWnd* pWnd);
//-----------------------------------------------------------------------
// Summary:
// Determines if item is enabled and clickable by user
// Returns:
// TRUE if items is neabled
//-----------------------------------------------------------------------
BOOL IsEnabled() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to enable/disable individual item of shortuct bar.
// Parameters:
// bEnabled - TRUE to enable item
//-----------------------------------------------------------------------
void SetEnabled(BOOL bEnabled);
protected:
CString m_strCaption; // Caption for the item.
CString m_strTooltip; // Tooltip for the item.
int m_nID; // Item's identifier.
CRect m_rcItem; // Bounding rectangle of the item
BOOL m_bVisible; // TRUE if the item is visible
BOOL m_bExpanded; // TRUE if the item is expanded
BOOL m_bHidden; // TRUE if the item is hidden
HWND m_hwndChild; // Child window associated with the item
BOOL m_bExpandButton; // True if the item is expand button
BOOL m_bNavigateButton; // True if the item is navigate button
DWORD_PTR m_dwData; // The 32-bit value associated with the item
CXTPShortcutBar* m_pShortcutBar; // Parent CXTPShortcutBar class
BOOL m_bSelected; // TRUE if item selected
int m_nIconId; // Identifier of the item's image.
BOOL m_bEnabled; // RUE if the item is Enabled
private:
friend class CXTPShortcutBar;
};
//-----------------------------------------------------------------------
// Summary:
// CXTPShortcutBar is a CWnd derived class. It is used to implement
// an Outlook2003 ShortcutBar style control.
//-----------------------------------------------------------------------
class _XTP_EXT_CLASS CXTPShortcutBar : public CWnd
{
//-----------------------------------------------------------------------
// Summary:
// Array of CXTPShortcutBarItem objects
//-----------------------------------------------------------------------
typedef CArray<CXTPShortcutBarItem*, CXTPShortcutBarItem*> CShortcutArray;
public:
//-----------------------------------------------------------------------
// Summary:
// Constructs a CXTPShortcutBar object.
//-----------------------------------------------------------------------
CXTPShortcutBar();
//-----------------------------------------------------------------------
// Summary:
// Destroys a CXTPShortcutBar object, handles cleanup and deallocation.
//-----------------------------------------------------------------------
virtual ~CXTPShortcutBar();
public:
//-----------------------------------------------------------------------
// Summary:
// This method creates the ShortcutBar control
// Parameters:
// dwStyle - Style for the ShortcutBar.
// rect - Specifies the size and position of the ShortcutBar control.
// pParentWnd - Specifies the parent window of the ShortcutBar control.
// nID - Specifies the ShortcutBar control ID.
// Returns:
// TRUE if successful, otherwise returns FALSE.
//-----------------------------------------------------------------------
BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);
//-----------------------------------------------------------------------
// Summary:
// Register the window class if it has not already been registered.
// Parameters:
// hInstance - Instance of resource where control is located
// Returns:
// TRUE if the window class was successfully registered.
//-----------------------------------------------------------------------
BOOL RegisterWindowClass(HINSTANCE hInstance = NULL);
public:
//-----------------------------------------------------------------------
// Summary:
// Call this function to retrieve state information from the registry or .INI file.
// Parameters:
// lpszProfileName - Points to a null-terminated string that specifies the name of a
// section in the initialization file or a key in the Windows registry where state
// information is stored.
//-----------------------------------------------------------------------
void LoadState(LPCTSTR lpszProfileName);
//-----------------------------------------------------------------------
// Summary:
// Call this function to save the state information to the registry or .INI file.
// Parameters:
// lpszProfileName - Points to a null-terminated string that specifies the name of a
// section in the initialization file or a key in the Windows registry where state
// information is stored.
//-----------------------------------------------------------------------
void SaveState(LPCTSTR lpszProfileName);
public:
//-----------------------------------------------------------------------
// Summary:
// Call this method to add a new item.
// Parameters:
// nID - Identifier of item that is to be added.
// pWnd - A Pointer to CWnd class associated with new item.
// Returns:
// A pointer to a CXTPShortcutBarItem object.
//-----------------------------------------------------------------------
CXTPShortcutBarItem* AddItem(UINT nID, CWnd* pWnd = NULL);
//-----------------------------------------------------------------------
// Summary:
// Call this method to find an item with the specified identifier.
// Parameters:
// nID - Identifier of the item needed to find.
// Returns:
// A pointer to a CXTPShortcutBarItem object.
//-----------------------------------------------------------------------
CXTPShortcutBarItem* FindItem(int nID) const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to select the specified item.
// Parameters:
// pItem - Item to be selected.
//-----------------------------------------------------------------------
void SelectItem(CXTPShortcutBarItem* pItem);
//-----------------------------------------------------------------------
// Summary:
// Call this method to show/hide expand button
// Parameters:
// bShow - TRUE to show; FALSE to hide
//-----------------------------------------------------------------------
void ShowExpandButton(BOOL bShow);
//-----------------------------------------------------------------------
// Summary:
// Determines if expand button visible
// Returns:
// TRUE if expand button is visible; otherwise FALSE;
//-----------------------------------------------------------------------
BOOL IsExpandButtonVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to remove the item.
// Parameters:
// nID - Identifier of the item to delete.
//-----------------------------------------------------------------------
void RemoveItem(int nID);
//-----------------------------------------------------------------------
// Summary:
// Call this method to remove all items.
//-----------------------------------------------------------------------
void RemoveAllItems();
//-----------------------------------------------------------------------
// Summary:
// This method retrieves an item with specified index.
// Parameters:
// nIndex - Specifies the zero-based index of the item to retrieve.
// Returns:
// A pointer to a CXTPShortcutBarItem object.
//-----------------------------------------------------------------------
CXTPShortcutBarItem* GetItem(int nIndex) const;
//-----------------------------------------------------------------------
// Summary:
// This method determines where a point lies in a specified item.
// Parameters:
// pt - Specifies the point to be tested.
// Returns:
// A pointer to a CXTPShortcutBarItem item that occupies the specified point or NULL
// if no item occupies the point.
//-----------------------------------------------------------------------
CXTPShortcutBarItem* HitTest(CPoint pt) const;
//-----------------------------------------------------------------------
// Summary:
// This method sets the minimum height of the client area in a ShortcutBar control.
// The default value is 200.
// Parameters:
// nMinHeight - Specifies the minimum height in pixels of the client.
//-----------------------------------------------------------------------
void SetMinimumClientHeight(int nMinHeight);
//-----------------------------------------------------------------------
// Summary:
// Call this method to determine gripper rectangle.
// Returns:
// CRect object contains gripper bounding rectangle.
//-----------------------------------------------------------------------
CRect GetGripperRect() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to get size of items
// Returns:
// CSize object contains size of items
//-----------------------------------------------------------------------
CSize GetItemSize() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to set size of items
// Parameters:
// szItem - Size of the item.
//-----------------------------------------------------------------------
void SetItemSize(CSize szItem);
//-----------------------------------------------------------------------
// Summary:
// This method determines the count of visible lines in the ShortcutBar control.
// Returns:
// Count of visible lines
// See Also:
// SetExpandedLinesCount
//-----------------------------------------------------------------------
int GetExpandedLinesCount() const;
//-----------------------------------------------------------------------
// Summary:
// This method determines the height of visible lines in the ShortcutBar control.
// Returns:
// Height of visible lines
// See Also:
// SetExpandedLinesHeight
//-----------------------------------------------------------------------
int GetExpandedLinesHeight() const;
//-----------------------------------------------------------------------
// Summary:
// This method sets the count of lines that are visible in the ShortcutBar control.
// Parameters:
// nCount - Number of visible lines.
// See Also:
// GetExpandedLinesCount
//-----------------------------------------------------------------------
void SetExpandedLinesCount(int nCount);
//-----------------------------------------------------------------------
// Summary:
// This method sets the the height of lines that are visible in the ShortcutBar control.
// Parameters:
// nHeight - Height of visible lines.
// See Also:
// SetExpandedLinesCount, GetExpandedLinesCount
//-----------------------------------------------------------------------
void SetExpandedLinesHeight(int nHeight);
//-----------------------------------------------------------------------
// Summary:
// Call this method to enable/disable resize client area
// Parameters:
// bAllowResize - TRUE to allow resize; FALSE to disable
// See Also:
// SetExpandedLinesCount
//-----------------------------------------------------------------------
void AllowGripperResize(BOOL bAllowResize);
//-----------------------------------------------------------------------
// Summary:
// Returns the hot item in the ShortcutBar control.
// Returns:
// Pointer to the hot item.
//-----------------------------------------------------------------------
CXTPShortcutBarItem* GetHotItem() const;
//-----------------------------------------------------------------------
// Summary:
// Returns the selected item in the ShortcutBar control.
// Returns:
// Pointer to the selected item.
//-----------------------------------------------------------------------
CXTPShortcutBarItem* GetSelectedItem() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to allow only one item to be selected.
// Parameters:
// bSingleSelection - TRUE to use single selection.
// See Also: IsSingleSelection, SetSelectItemOnFocus
//-----------------------------------------------------------------------
void SetSingleSelection(BOOL bSingleSelection = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get Single Selection property of control.
// See Also: SetSingleSelection, SetSelectItemOnFocus
//-----------------------------------------------------------------------
BOOL IsSingleSelection() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to show active item on top of controls
// Parameters:
// bActiveItemOnTop - TRUE to show active item on top of controls
// See Also: IsShowActiveItemOnTop
//-----------------------------------------------------------------------
void ShowActiveItemOnTop(BOOL bActiveItemOnTop);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get ShowActiveItemOnTop property of control.
// See Also: ShowActiveItemOnTop
//-----------------------------------------------------------------------
BOOL IsShowActiveItemOnTop() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to allow resize gripper by pixel
// Parameters:
// bAllowFreeResize - TRUE to allow resize gripper by pixel
// See Also: IsShowActiveItemOnTop
//-----------------------------------------------------------------------
void AllowFreeResize(BOOL bAllowFreeResize);
// Summary:
// Determines if gripper allowed to resize by pixel.
// See Also: ShowActiveItemOnTop
//-----------------------------------------------------------------------
BOOL IsAllowFreeResize() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to allow collapse items
// Parameters:
// bAllowCollapse - TRUE to allow collapse items
//-----------------------------------------------------------------------
void AllowCollapse(BOOL bAllowCollapse);
//-----------------------------------------------------------------------
// Summary:
// Call this method to show gripper.
// Parameters:
// bShowGripper - TRUE to show gripper; FALSE to hide
//-----------------------------------------------------------------------
void ShowGripper(BOOL bShowGripper);
//-----------------------------------------------------------------------
// Summary:
// Returns the pressed item in the ShortcutBar control.
// Returns:
// Pointer to the pressed item.
//-----------------------------------------------------------------------
CXTPShortcutBarItem* GetPressedItem() const;
//-----------------------------------------------------------------------
// Summary:
// Determines visibility of client pane.
// Returns:
// TRUE if client pane is visible.
//-----------------------------------------------------------------------
BOOL IsClientPaneVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to show or hide client pane.
// Parameters:
// bVisible - TRUE to show client pane; FALSE to hide.
//-----------------------------------------------------------------------
void SetClientPaneVisible(BOOL bVisible);
//-----------------------------------------------------------------------
// Summary:
// Call this method to set new image manager.
// Parameters:
// pImageManager - Points to a CXTPImageManager object to be set
// Example:
// <code>
// CXTPImageManager* pImageManager = new CXTPImageManager();
// pImageManager->SetIcons(IDR_MAINFRAME);
// m_wndShortcutBar.SetImageManager(pImageManager);
// </code>
// See Also:
// GetImageManager
//-----------------------------------------------------------------------
void SetImageManager(CXTPImageManager* pImageManager);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get a pointer to the image manager of shortcut
// bar control.
// Returns:
// Pointer to the image manager of shortcut bar control.
// Remarks:
// The image manager is used to hold all of the icons displayed in the
// shortcut bar control.
// See Also:
// SetImageManager
//-----------------------------------------------------------------------
CXTPImageManager* GetImageManager() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to determine how many CXTPShortcutBarItem(s) are int he
// shortcut bar.
// Returns:
// Number of shortcut bar items in the shortcut bar.
//-----------------------------------------------------------------------
int GetItemCount() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to set right-to-left mode.
// Parameters:
// bRightToLeft - TRUE to set right-to-left reading-order properties.
//-----------------------------------------------------------------------
void SetLayoutRTL(BOOL bRightToLeft);
//-----------------------------------------------------------------------
// Summary:
// Retrieves bounding rectangle of shortcut bar client
// Returns:
// Bounding rectangle of shortcut bar client
//-----------------------------------------------------------------------
CRect GetClientPaneRect() const;
public:
//-----------------------------------------------------------------------
// Summary:
// Call this member to switch the visual theme of the ShortcutBar control.
// Parameters:
// paintTheme - New visual theme. Can be any of the values listed in the Remarks section.
// Remarks:
// paintTheme can be one of the following:
// * <b>xtpShortcutThemeOffice2000</b> Enables Office 2000 style theme.
// * <b>xtpShortcutThemeOfficeXP</b> Enables Office XP style theme.
// * <b>xtpShortcutThemeOffice2003</b> Enables Office 2003 style theme.
// * <b>xtpTaskPanelThemeShortcutBarOffice2007</b> Enables Office 2007 style theme.
//
// See Also:
// GetCurrentTheme, SetCustomTheme, XTPShortcutBarPaintTheme
//-----------------------------------------------------------------------
void SetTheme(XTPShortcutBarPaintTheme paintTheme);
//-----------------------------------------------------------------------
// Summary:
// Call this member to set a custom theme.
// Parameters:
// pPaintManager - New paint manager.
// See Also:
// GetCurrentTheme, SetTheme, XTPShortcutBarPaintTheme
//-----------------------------------------------------------------------
void SetCustomTheme(CXTPShortcutBarPaintManager* pPaintManager);
//-----------------------------------------------------------------------
// Summary:
// Call this member to get the current paint manager.
// Returns:
// The current paint manager.
//-----------------------------------------------------------------------
CXTPShortcutBarPaintManager* GetPaintManager() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to get the current visual theme.
// Returns:
// The current theme.
// See Also:
// SetTheme, SetCustomTheme, XTPShortcutBarPaintTheme
//-----------------------------------------------------------------------
XTPShortcutBarPaintTheme GetCurrentTheme() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to redraw control.
// Parameters:
// lpRect - The rectangular area of the bar that is invalid.
// bAnimate - TRUE to animate changes in bounding rectangle.
//-------------------------------------------------------------------------
//-----------------------------------------------------------------------
void RedrawControl(LPCRECT lpRect = NULL, BOOL bAnimate = FALSE);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get tooltip context pointer.
//-----------------------------------------------------------------------
CXTPToolTipContext* GetToolTipContext() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to determine the number of visible items
// Returns:
// Number of visible items
//-----------------------------------------------------------------------
int GetVisibleItemsCount() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to determine the number of collapsed items
// Returns:
// Number of collapsed items
//-----------------------------------------------------------------------
int GetCollapsedItemsCount() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to reposition items.
//-----------------------------------------------------------------------
virtual void Reposition();
// ----------------------------------------------------------------------
// Summary:
// Called by the framework to draw the shortcut bar using the specified
// device context.
// Parameters:
// pDC : Pointer to a valid device context.
// rcClipBox : The rectangular area of the control that is invalid.
//-----------------------------------------------------------------------
virtual void OnDraw(CDC* pDC, CRect rcClipBox);
//-----------------------------------------------------------------------
// Summary:
// Call this method to enable animation for shortcut bar
// Parameters:
// bEnable - TRUE to enable animation; FALSE to disable
//-----------------------------------------------------------------------
void EnableAnimation(BOOL bEnable = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Determines if ShortcutBar in minimized state
// Returns:
// TRUE if Width of shortcutBar is less that m_nMinimizedWidth parameter
// See Also: AllowMinimize
//-----------------------------------------------------------------------
BOOL IsShortcutBarMinimized() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to show Navigation Pane if user resize ShortcutBar to small size
// Parameters:
// bAllowMinimize - TRUE to allow minimize feature
// nMinimizedWidth - Width of shortcutBar considered as minimized
//-----------------------------------------------------------------------
void AllowMinimize(BOOL bAllowMinimize = TRUE, int nMinimizedWidth = 32);
//-----------------------------------------------------------------------
// Summary:
// Call this method to show Minimize button in caption of the Pane.
// Parameters:
// bShowMinimizeButton - TRUE to show minimize button
//-----------------------------------------------------------------------
void ShowMinimizeButton(BOOL bShowMinimizeButton);
BOOL IsMinimizeButtonVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if Minimized ShortcutBar feature is enabled
// Returns:
// TRUE to show Navigation Pane item when Width of ShortcutBar is less than m_nMinimizedWidth
//-----------------------------------------------------------------------
BOOL IsAllowMinimize() const;
CXTPShortcutBarItem* GetNavigationPaneItem() const;
virtual void OnMinimizeButtonClicked();
protected:
//-----------------------------------------------------------------------
// Summary:
// This method is called when reposition is done.
//-----------------------------------------------------------------------
virtual void OnRepositionDone();
//-----------------------------------------------------------------------
// Summary:
// This method is called when expand button is pressed.
// Parameters:
// pExpandButton - A pointer to expand button.
//-----------------------------------------------------------------------
virtual void OnExpandButtonDown(CXTPShortcutBarItem* pExpandButton);
//-----------------------------------------------------------------------
// Summary:
// This method is called when Navigate button is pressed.
// Parameters:
// pNavigateButton - A pointer to Navigate button.
//-----------------------------------------------------------------------
void OnNavigateButtonDown(CXTPShortcutBarItem* pNavigateButton);
//-----------------------------------------------------------------------
// Summary:
// Call this method to set hot item.
// Parameters:
// pItem - Item to be hot.
//-----------------------------------------------------------------------
void SetHotItem(CXTPShortcutBarItem* pItem);
protected:
//{{AFX_CODEJOCK_PRIVATE
DECLARE_MESSAGE_MAP()
//{{AFX_VIRTUAL(CXTPShortcutBar)
BOOL OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult);
INT_PTR OnToolHitTest(CPoint point, TOOLINFO* pTI) const;
void PreSubclassWindow();
BOOL PreCreateWindow(CREATESTRUCT& cs);
//}}AFX_VIRTUAL
//{{AFX_MSG(CXTPShortcutBar)
afx_msg void OnPaint();
afx_msg LRESULT OnPrintClient(WPARAM wParam, LPARAM /*lParam*/);
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnDestroy();
afx_msg void OnTimer(UINT_PTR nIDEvent);
afx_msg void OnNcPaint();
afx_msg void OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* /*lpncsp*/);
afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
afx_msg void OnCaptureChanged(CWnd* pWnd);
afx_msg void OnMouseLeave();
afx_msg void OnSysColorChange();
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
afx_msg void OnRButtonUp(UINT nFlags, CPoint point) ;
afx_msg LRESULT OnExpandPopupExecute(WPARAM wparam, LPARAM lParam);
afx_msg void OnShowMoreButtons();
afx_msg void OnShowFewerButtons();
afx_msg void OnUpdateShowMoreButtons(CCmdUI* pCmdUI);
afx_msg void OnUpdateShowFewerButtons(CCmdUI* pCmdUI);
afx_msg void OnSetFocus(CWnd* pWnd);
//}}AFX_MSG
//}}AFX_CODEJOCK_PRIVATE
private:
BOOL Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext = NULL);
CXTPShortcutBarItem* CreateNavigationItem();
CXTPShortcutBarItem* CreateConfigureButton();
protected:
CXTPShortcutBarPaintManager* m_pPaintManager; // Current paint manager.
CXTPImageManager* m_pImageManager; // Current image manager.
int m_nExpandedLines; // Number of lines currently visible
int m_nDesiredExpandedLinesHeight; // Desired visible lines height height.
int m_nMinClientHeight; // The height of client area.
BOOL m_bAllowResize; // TRUE to allow resize
XTPShortcutBarPaintTheme m_paintTheme; // Current theme.
CShortcutArray m_arrItems; // Array of items.
CSize m_szItem; // Size of items
CRect m_rcClient; // Client's rectangle.
CRect m_rcGripper; // Gripper's rectangle.
HWND m_hwndClient; // Client window handle
HCURSOR m_hSizeCursor; // Handle to the cursor displayed for the size icon.
BOOL m_bTrackingSize; // TRUE if control in tracking mode.
BOOL m_bShowActiveItemOnTop; // TRUE to show active item on top
BOOL m_bAllowFreeResize; // TRUE to allow resize gripper by pixel;
BOOL m_bAllowCollapse; // TRUE to allow collapse items.
BOOL m_bShowGripper; // TRUE to show gripper.
CXTPShortcutBarItem* m_pHotItem; // Pointer to hot item.
CXTPShortcutBarItem* m_pSelectedItem; // Pointer to selected item.
CXTPShortcutBarItem* m_pPressedItem; // Pointer to pressed item.
CXTPShortcutBarPopup* m_pActivePopup;
CXTPShortcutBarItem* m_pNavigationPaneItem;
BOOL m_bClientPaneVisible; // TRUE is client Pane in ShortcutBar is visible
HCURSOR m_hHandCursor; // Hand cursor that is displayed when the cursor is positioned over a shortcut bar item.
BOOL m_bSingleSelection; // TRUE to use single selected items.
CXTPToolTipContext* m_pToolTipContext; // Tooltip Context.
BOOL m_bPreSubclassWindow; // True if PreSubclassWindow was called
CXTPShortcutBarAnimation* m_pAnimation; // Animation helper
int m_bAllowMinimize;
int m_nMinimizedWidth;
BOOL m_bMinimized;
BOOL m_bShowMinimizeButton;
friend class CXTPShortcutBarItem;
friend class CShortcutBarCtrl;
};
//////////////////////////////////////////////////////////////////////
AFX_INLINE CString CXTPShortcutBarItem::GetCaption() const{
return m_strCaption;
}
AFX_INLINE CString CXTPShortcutBarItem::GetTooltip() const{
return m_strTooltip;
}
AFX_INLINE BOOL CXTPShortcutBarItem::IsItemExpandButton() const{
return m_bExpandButton;
}
AFX_INLINE BOOL CXTPShortcutBarItem::IsExpanded() const {
return m_bExpanded;
}
AFX_INLINE CXTPShortcutBar* CXTPShortcutBarItem::GetShortcutBar() const {
return m_pShortcutBar;
}
AFX_INLINE CRect CXTPShortcutBarItem::GetItemRect() const {
return m_rcItem;
}
AFX_INLINE void CXTPShortcutBarItem::SetItemData(DWORD_PTR dwData) {
m_dwData = dwData;
}
AFX_INLINE DWORD_PTR CXTPShortcutBarItem::GetItemData() const {
return m_dwData;
}
AFX_INLINE CWnd* CXTPShortcutBarItem::GetClientWindow() const {
return CWnd::FromHandle(m_hwndChild);
}
AFX_INLINE CXTPShortcutBarItem* CXTPShortcutBar::GetHotItem() const {
return m_pHotItem;
}
AFX_INLINE CXTPShortcutBarItem* CXTPShortcutBar::GetSelectedItem() const {
return m_pSelectedItem;
}
AFX_INLINE CXTPShortcutBarItem* CXTPShortcutBar::GetPressedItem() const {
return m_pPressedItem;
}
AFX_INLINE CRect CXTPShortcutBar::GetGripperRect() const {
return m_rcGripper;
}
AFX_INLINE CSize CXTPShortcutBar::GetItemSize() const {
return m_szItem;
}
AFX_INLINE void CXTPShortcutBar::SetItemSize(CSize szItem) {
m_szItem = szItem;
}
AFX_INLINE int CXTPShortcutBar::GetExpandedLinesCount() const{
return m_nExpandedLines;
}
AFX_INLINE BOOL CXTPShortcutBar::IsClientPaneVisible() const{
return m_bClientPaneVisible;
}
AFX_INLINE void CXTPShortcutBar::SetClientPaneVisible(BOOL bVisible) {
m_bClientPaneVisible = bVisible;
Reposition();
}
AFX_INLINE CXTPShortcutBarPaintManager* CXTPShortcutBar::GetPaintManager() const{
return m_pPaintManager;
}
AFX_INLINE void CXTPShortcutBar::SetMinimumClientHeight(int nMinHeight) {
m_nMinClientHeight = nMinHeight;
}
AFX_INLINE XTPShortcutBarPaintTheme CXTPShortcutBar::GetCurrentTheme() const{
return m_paintTheme;
}
AFX_INLINE BOOL CXTPShortcutBar::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext) {
return CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext);
}
AFX_INLINE void CXTPShortcutBar::AllowGripperResize(BOOL bAllowResize) {
m_bAllowResize = bAllowResize;
}
AFX_INLINE void CXTPShortcutBar::SetSingleSelection(BOOL bSingleSelection) {
m_bSingleSelection = bSingleSelection;
Reposition();
}
AFX_INLINE BOOL CXTPShortcutBar::IsSingleSelection() const{
return m_bSingleSelection;
}
AFX_INLINE void CXTPShortcutBar::ShowActiveItemOnTop(BOOL bActiveItemOnTop) {
m_bShowActiveItemOnTop = bActiveItemOnTop;
Reposition();
}
AFX_INLINE BOOL CXTPShortcutBar::IsShowActiveItemOnTop() const {
return m_bShowActiveItemOnTop;
}
AFX_INLINE void CXTPShortcutBar::AllowFreeResize(BOOL bAllowFreeResize) {
m_bAllowFreeResize = bAllowFreeResize;
Reposition();
}
AFX_INLINE BOOL CXTPShortcutBar::IsAllowFreeResize() const {
return m_bAllowFreeResize;
}
AFX_INLINE void CXTPShortcutBar::AllowCollapse(BOOL bAllowCollapse) {
m_bAllowCollapse = bAllowCollapse;
Reposition();
}
AFX_INLINE void CXTPShortcutBar::ShowGripper(BOOL bShowGripper) {
m_bShowGripper = bShowGripper;
Reposition();
}
AFX_INLINE int CXTPShortcutBar::GetExpandedLinesHeight() const {
return m_nDesiredExpandedLinesHeight;
}
AFX_INLINE CRect CXTPShortcutBar::GetClientPaneRect() const {
return m_rcClient;
}
AFX_INLINE void CXTPShortcutBar::AllowMinimize(BOOL bAllowMinimize, int nMinimizedWidth) {
m_bAllowMinimize = bAllowMinimize;
m_nMinimizedWidth = nMinimizedWidth;
}
AFX_INLINE void CXTPShortcutBar::ShowMinimizeButton(BOOL bShowMinimizeButton) {
m_bShowMinimizeButton = bShowMinimizeButton;
Reposition();
}
AFX_INLINE BOOL CXTPShortcutBar::IsAllowMinimize() const {
return m_bAllowMinimize;
}
AFX_INLINE CXTPShortcutBarItem* CXTPShortcutBar::GetNavigationPaneItem() const {
return m_pNavigationPaneItem;
}
AFX_INLINE BOOL CXTPShortcutBar::IsMinimizeButtonVisible() const {
return m_bShowMinimizeButton;
}
#endif // !defined(__XTPSHORTCUTBAR_H__)