// XTPRibbonBar.h: interface for the CXTPRibbonBar class.
//
// This file is a part of the XTREME RIBBON 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(__XTPRIBBONBAR_H__)
#define __XTPRIBBONBAR_H__
//}}AFX_CODEJOCK_PRIVATE
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CXTPRibbonQuickAccessControls;
class CXTPRibbonTab;
class CXTPRibbonControlTab;
class CXTPTabPaintManager;
class CXTPRibbonBar;
class CXTPRibbonGroup;
class CXTPCommandBarsFrameHook;
class CXTPRibbonTabContextHeaders;
class CXTPRibbonGroups;
class CXTPRibbonPaintManager;
class CXTPRibbonControlSystemButton;
//-----------------------------------------------------------------------
// Summary:
// The WM_XTP_RIBBONMINIMIZE message is sent to CXTPCommandBars site when user minimized RibonBar
//-----------------------------------------------------------------------
#define WM_XTP_RIBBONMINIMIZE (WM_XTP_COMMANDBARS_BASE + 25)
#define WM_XTP_CUSTOMIZATION_RIBBONRESET (WM_XTP_COMMANDBARS_BASE + 27)
//===========================================================================
// Summary:
// CXTPRibbonBar is a CXTPMenuBar derived class, It represents Ribbon control from Office 2007.
// Example:
// The following code sample demonstrates how to create CXTPRibbonBar:
//
// CXTPRibbonBar* pRibbonBar = (CXTPRibbonBar*)pCommandBars->Add(_T("The Ribbon"), xtpBarTop, RUNTIME_CLASS(CXTPRibbonBar));
//
//===========================================================================
class _XTP_EXT_CLASS CXTPRibbonBar : public CXTPMenuBar, public CXTPRibbonScrollableBar
{
private:
class CControlQuickAccessMorePopup;
class CControlQuickAccessCommand;
private:
DECLARE_XTP_COMMANDBAR(CXTPRibbonBar)
public:
//-----------------------------------------------------------------------
// Summary:
// Constructs a CXTPRibbonBar object
//-----------------------------------------------------------------------
CXTPRibbonBar();
//-----------------------------------------------------------------------
// Summary:
// Destroys a CXTPRibbonBar object, handles cleanup and deallocation
//-----------------------------------------------------------------------
virtual ~CXTPRibbonBar();
public:
//-----------------------------------------------------------------------
// Summary:
// Cal this method to add new tab for ribbon bar
// Parameters:
// lpszCaption - Caption of tab to be added
// nID - Identifier of tab to be added
// Returns:
// Pointer to new CXTPRibbonTab object
// See Also: InsertTab
//-----------------------------------------------------------------------
CXTPRibbonTab* AddTab(LPCTSTR lpszCaption);
CXTPRibbonTab* AddTab(int nID); //
//-----------------------------------------------------------------------
// Summary:
// Call this method to insert new tab for ribbon bar to specified position
// Parameters:
// nItem - Position to insert new tab
// nID - Identifier of tab
// Returns:
// Pointer to new CXTPRibbonTab object
// See Also: AddTab
//-----------------------------------------------------------------------
CXTPRibbonTab* InsertTab(int nItem, int nID);
//-----------------------------------------------------------------------
// Summary:
// Call this method to insert new tab for ribbon bar to specified position
// Parameters:
// nItem - Position to insert new tab
// lpszCaption - Caption of tab to be added
// nID - Identifier of tab
// Returns:
// Pointer to new CXTPRibbonTab object
// See Also: AddTab
//-----------------------------------------------------------------------
CXTPRibbonTab* InsertTab(int nItem, LPCTSTR lpszCaption, int nID = 0);
CXTPRibbonTab* InsertTab(int nItem, CXTPRibbonTab* pTab);
//-----------------------------------------------------------------------
// Summary:
// Cal this method to get current selected tab
// Returns:
// Pointer to current selected CXTPRibbonTab object
// See Also: SetCurSel
//-----------------------------------------------------------------------
CXTPRibbonTab* GetSelectedTab() const;
//-----------------------------------------------------------------------
// Summary:
// Cal this method to get tab in specified position
// Parameters:
// nIndex - Index of tab to retrieve
// Returns:
// Pointer to CXTPRibbonTab object in specified position
// See Also: GetTabCount
//-----------------------------------------------------------------------
CXTPRibbonTab* GetTab(int nIndex) const;
//-----------------------------------------------------------------------
// Summary:
// Cal this method to find tab by its identifier
// Parameters:
// nId - Identifier of tab to be found
// Returns:
// Pointer to CXTPRibbonTab object with specified identifier
// See Also: FindGroup
//-----------------------------------------------------------------------
CXTPRibbonTab* FindTab(int nId) const;
//-----------------------------------------------------------------------
// Summary:
// Cal this method to find group by its identifier
// Parameters:
// nId - Identifier of group to be found
// Returns:
// Pointer to CXTPRibbonGroup object with specified identifier
// See Also: FindTab
//-----------------------------------------------------------------------
CXTPRibbonGroup* FindGroup(int nId) const;
//-----------------------------------------------------------------------
// Summary:
// Retrieves the number of tabs in the ribbon bar.
// Returns:
// Number of tabs in the ribbon bar.
// See Also: GetTab
//-----------------------------------------------------------------------
int GetTabCount() const;
//-----------------------------------------------------------------------
// Summary:
// Retrieves ribbon paint manager.
// Returns:
// Pointer to CXTPRibbonPaintManager object
// See Also: AddTab
//-----------------------------------------------------------------------
CXTPRibbonPaintManager* GetRibbonPaintManager() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to select tab.
// Parameters:
// nIndex - Index of tab to be selected
// See Also: GetSelectedTab
//-----------------------------------------------------------------------
void SetCurSel(int nIndex);
//-----------------------------------------------------------------------
// Summary:
// Call this function to get the size of the command bar button.
// Returns:
// The width and height values of the command bar button.
//-----------------------------------------------------------------------
CSize GetButtonSize() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to get select tab index.
// See Also: SetCurSel
//-----------------------------------------------------------------------
int GetCurSel() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to get a pointer to the tab paint manager.
// The tab paint manager is used to customize the appearance of
// CXTPTabManagerItem objects and the tab manager. I.e. Tab colors,
// styles, etc... This member must be overridden in
// derived classes.
// Returns:
// Pointer to CXTPTabPaintManager that contains the visual elements
// of the tabs.
//-----------------------------------------------------------------------
CXTPTabPaintManager* GetTabPaintManager() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to get highlighted group
// Returns:
// CXTPRibbonGroup object under mouse cursor
// See Also: CXTPRibbonGroup
//-----------------------------------------------------------------------
CXTPRibbonGroup* GetHighlightedGroup() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if groups part of ribbon bar is visible
// Returns:
// TRUE if groups are visible
// See Also: SetGroupsVisible
//-----------------------------------------------------------------------
BOOL IsGroupsVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if tabs part of ribbon bar is visible
// Returns:
// TRUE if tabs are visible
// See Also: SetTabsVisible
//-----------------------------------------------------------------------
BOOL IsTabsVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if ribbon bar is visible
//-----------------------------------------------------------------------
BOOL IsRibbonBarVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to show or hide the ribbon.
// Parameters:
// bVisible - TRUE to show the ribbon; FALSE to hide.
//-----------------------------------------------------------------------
virtual void SetVisible(BOOL bVisible);
//-----------------------------------------------------------------------
// Summary:
// Call this method to hide/show groups part of ribbon bar
// Parameters:
// bVisible - TRUE to show groups
// See Also: IsGroupsVisible
//-----------------------------------------------------------------------
void SetGroupsVisible(BOOL bVisible);
//-----------------------------------------------------------------------
// Summary:
// Call this method to hide/show tabs part of ribbon bar
// Parameters:
// bVisible - TRUE to show tabs
// See Also: IsTabsVisible
//-----------------------------------------------------------------------
void SetTabsVisible(BOOL bVisible);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get CXTPRibbonControlTab that represents ribbon tabs
//-----------------------------------------------------------------------
CXTPRibbonControlTab* GetControlTab() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to set minimum width before ribbon bar disappear
// Parameters:
// nMinVisibleWidth - Minimum width.
// Remarks:
// Default value is 250 pixels
// See Also: GetMinimumVisibleWidth
//-----------------------------------------------------------------------
void SetMinimumVisibleWidth(int nMinVisibleWidth);
void SetMinimumVisibleSize(int nMinVisibleWidth, int nMinVisibleHeight); //
//-----------------------------------------------------------------------
// Summary:
// Call this method to get minimum width before ribbon bar disappear
// Returns:
// Minimum width before ribbon bar disappear.
// See Also: SetMinimumVisibleWidth
//-----------------------------------------------------------------------
int GetMinimumVisibleWidth() const;
//-----------------------------------------------------------------------
// Summary:
// Retrieves collection of Quick Access controls.
// Returns:
// Pointer to CXTPRibbonQuickAccessControls contained Quick Access controls.
//-----------------------------------------------------------------------
CXTPRibbonQuickAccessControls* GetQuickAccessControls() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to add ribbon top-left system button.
// Parameters:
// nID - Identifier of system button
// See Also: GetSystemButton
//-----------------------------------------------------------------------
CXTPControlPopup* AddSystemButton(int nID = 0);
//-----------------------------------------------------------------------
// Summary:
// Call this method to get ribbon top-left system button.
// See Also: AddSystemButton
//-----------------------------------------------------------------------
CXTPRibbonControlSystemButton* GetSystemButton() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member function to determine if the CommandBar is a
// CXTPRibbonBar.
// Returns:
// Returns TRUE if the CommandBar is a CXTPRibbonBar, otherwise FALSE
// See Also: CXTPCommandBar, CXTPRibbonBar
//-----------------------------------------------------------------------
virtual BOOL IsRibbonBar() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to remove all tab
// See Also: RemoveTab
//-----------------------------------------------------------------------
void RemoveAllTabs();
//-----------------------------------------------------------------------
// Summary:
// Call this member to remove single tab
// Parameters:
// nIndex - Index of tab to remove
// See Also: RemoveTab
//-----------------------------------------------------------------------
void RemoveTab(int nIndex);
//-----------------------------------------------------------------------
// Summary:
// Call this method to be sure control is visible on ribbon bar
// Parameters:
// pControl - CXTPControl child that need to check
//-----------------------------------------------------------------------
virtual void EnsureVisible(CXTPControl* pControl);
BOOL OnFrameMouseWheel(BOOL bForward);
public:
//-----------------------------------------------------------------------
// Summary:
// Call this method to enable Office 2007 frame.
// Parameters:
// bEnable - TRUE to enable Office 2007 frame; FLASE - to disable
// See Also: IsFrameThemeEnabled
//-----------------------------------------------------------------------
void EnableFrameTheme(BOOL bEnable = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Determines if Office 2007 frame enabled
// See Also: IsFrameThemeEnabled
//-----------------------------------------------------------------------
BOOL IsFrameThemeEnabled() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to show Quick Access controls below ribbon bar
// Parameters:
// bBelow - TRUE to show below ribbon; FALSE - above.
// See Also: IsQuickAccessBelowRibbon
//-----------------------------------------------------------------------
void ShowQuickAccessBelowRibbon(BOOL bBelow = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Determine if Quick Access controls located below ribbon bar
// See Also: ShowQuickAccessBelowRibbon
//-----------------------------------------------------------------------
BOOL IsQuickAccessBelowRibbon() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to show/hide quick access
// Parameters:
// bShow - TRUE to show quick access; FALSE to hide
// See Also: IsQuickAccessVisible, ShowQuickAccessBelowRibbon
//-----------------------------------------------------------------------
void ShowQuickAccess(BOOL bShow = TRUE);
//-----------------------------------------------------------------------
// Summary:
// Determines if quick access is visible
// Returns:
// TRUE if quick access is visible
// See Also: ShowQuickAccess
//-----------------------------------------------------------------------
BOOL IsQuickAccessVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to allow same controls for quick access
// Parameters:
// bAllow - TRUE to allow add same controls for quick access
// See Also: IsAllowQuickAccessDuplicates, ShowQuickAccessBelowRibbon
//-----------------------------------------------------------------------
void AllowQuickAccessDuplicates(BOOL bAllow);
//-----------------------------------------------------------------------
// Summary:
// Call this method to allow customization for quick access
// Parameters:
// bAllow - TRUE to allow customization for quick access
// See Also: IsAllowQuickAccessDuplicates, ShowQuickAccessBelowRibbon
//-----------------------------------------------------------------------
void AllowQuickAccessCustomization(BOOL bAllow);
//-----------------------------------------------------------------------
// Summary:
// Determines if user can add 2 or more same controls to quick access
// Returns: TRUE if duplicates allowed
// See Also: AllowQuickAccessDuplicates
//-----------------------------------------------------------------------
BOOL IsAllowQuickAccessDuplicates() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to select next or previous tab
// Parameters:
// bNext - TRUE to select next
//-----------------------------------------------------------------------
void SelectNextTab(BOOL bNext);
//-----------------------------------------------------------------------
// Summary:
// Call this method to minimize Ribbon Bar
// Parameters:
// bMinimized - TRUE to minimize Ribbon Bar.
//-----------------------------------------------------------------------
virtual void SetRibbonMinimized(BOOL bMinimized);
//-----------------------------------------------------------------------
// Summary:
// Determines if ribbon bar is minimized
//-----------------------------------------------------------------------
BOOL IsRibbonMinimized() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to disable minimize feature of Ribbon Bar
// Parameters:
// bAllow - TRUE to allow minimize ribbon bar; FALSE to forbid
//-----------------------------------------------------------------------
void AllowMinimize(BOOL bAllow);
public:
//-----------------------------------------------------------------------
// Summary:
// When switching tabs, RebuildControls first deletes all the controls
// from the old tab groups. Then controls are added to the tab groups
// of the tab to be selected. Finally, the new tab is selected.
// Parameters:
// pSelected - Tab to be selected.
// See Also: CXTPRibbonControlTab::SetSelectedItem, CXTPRibbonTab::GetGroups
//-----------------------------------------------------------------------
void RebuildControls(CXTPRibbonTab* pSelected);
//-----------------------------------------------------------------------
// Summary:
// Gets the bounding rectangle for the ribbon tabs.
// Returns:
// Bounding rectangle for the ribbon tabs.
// See Also: CXTPRibbonThemeOffice2007Theme::FillRibbonBar
//-----------------------------------------------------------------------
CRect GetTabControlRect() const;
//-----------------------------------------------------------------------
// Summary:
// Gets the bounding rectangle for the ribbon caption.
// Returns:
// Bounding rectangle for the ribbon caption.
// See Also: GetCaptionTextRect, GetQuickAccessRect, GetTabControlRect
//-----------------------------------------------------------------------
CRect GetCaptionRect() const;
//-----------------------------------------------------------------------
// Summary:
// Gets the bounding rectangle for the ribbon caption text.
// Returns:
// Bounding rectangle for the ribbon caption text.
// See Also: GetCaptionRect, GetQuickAccessRect, GetTabControlRect
//-----------------------------------------------------------------------
CRect GetCaptionTextRect() const;
//-----------------------------------------------------------------------
// Summary:
// Gets the bounding rectangle for the ribbon Quick Access controls.
// Returns:
// Bounding rectangle for the ribbon Quick Access controls.
// See Also: GetCaptionRect, GetCaptionTextRect, GetTabControlRect
//-----------------------------------------------------------------------
CRect GetQuickAccessRect() const;
//-----------------------------------------------------------------------
// Summary:
// This member function determines which ribbon group,
// if any, is at a specified position.
// Parameters:
// point - A CPoint that contains the coordinates of the point to test.
// Returns:
// The CXTPRibbonGroup that is at the specified point, if no group is
// at the point, then NULL is returned.
//-----------------------------------------------------------------------
CXTPRibbonGroup* HitTestGroup(CPoint point) const;
//-----------------------------------------------------------------------
// Summary:
// This method retrieves tabs area height
// Returns:
// Tabs area height
// See Also: GetGroupsHeight
//-----------------------------------------------------------------------
virtual int GetTabsHeight() const;
//-----------------------------------------------------------------------
// Summary:
// This method retrieves Quick Access area height
// Returns:
// Quick Access area height
// See Also: GetGroupsHeight, GetTabsHeight
//-----------------------------------------------------------------------
int GetQuickAccessHeight() const;
//-----------------------------------------------------------------------
// Summary:
// Calculates Quick Access area height
// Returns:
// Quick Access area height
//-----------------------------------------------------------------------
int CalcQuickAccessHeight();
//-----------------------------------------------------------------------
// Summary:
// This method retrieves group area height
// Returns:
// Group area height
// See Also: GetTabsHeight
//-----------------------------------------------------------------------
virtual int GetGroupsHeight();
//-----------------------------------------------------------------------
// Summary:
// This method retrieves group client area height
// Returns:
// Group client area height
// See Also: GetGroupsHeight, GetTabsHeight
//-----------------------------------------------------------------------
virtual int CalcClientHeight();
//-----------------------------------------------------------------------
// Summary:
// Retrieves Groups bounding rectangle
// Returns:
// Groups bounding rectangle
//-----------------------------------------------------------------------
CRect GetGroupsRect() const;
//-----------------------------------------------------------------------
// Summary:
// This method calculates groups height using GetLargeIconSize method and height of captions
// Returns:
// Height of ribbon groups
// See Also: GetGroupsHeight
//-----------------------------------------------------------------------
virtual int CalcGroupsHeight();
//-----------------------------------------------------------------------
// Summary:
// Call this method to set height of the ribbon groups
// Parameters:
// nHeight - Height of groups to set
// See Also: GetTabsHeight
//-----------------------------------------------------------------------
void SetGroupsHeight(int nHeight);
//-----------------------------------------------------------------------
// Summary:
// Call this member to get caption height of ribbon bar
// Returns: Caption height in pixels
// See Also: CalcGroupsHeight
//-----------------------------------------------------------------------
int GetCaptionHeight() const;
//-----------------------------------------------------------------------
// Summary:
// This method retrieves Context Headers collection;
// Returns:
// Pointer to CXTPRibbonTabContextHeaders class contained
// CXTPRibbonTabContextHeader collection
// See Also: CXTPRibbonTabContextHeader
//-----------------------------------------------------------------------
CXTPRibbonTabContextHeaders* GetContextHeaders() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if control belongs to quick access controls.
// Parameters:
// pControl - Control to test
// Returns:
// TRUE if control located in quick access area.
//-----------------------------------------------------------------------
BOOL IsQuickAccessControl(CXTPControl* pControl) const;
//-----------------------------------------------------------------------
// Summary:
// Determines if control can be added to quick access controls.
// Parameters:
// pControl - Control to test
// Returns:
// TRUE if control can be added in quick access area.
//-----------------------------------------------------------------------
virtual BOOL IsAllowQuickAccessControl(CXTPControl* pControl);
//-----------------------------------------------------------------------
// Summary:
// This method is called to draw the command bar in the given context.
// Parameters:
// pDC - Pointer to a valid device context
// rcClipBox - The rectangular area of the control that is invalid
//-----------------------------------------------------------------------
virtual void DrawCommandBar(CDC* pDC, CRect rcClipBox);
//-----------------------------------------------------------------------
// Summary:
// Returns CXTPCommandBarsFrameHook hook window used to skin frame.
// See Also: EnableFrameTheme
//-----------------------------------------------------------------------
CXTPCommandBarsFrameHook* GetFrameHook() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if Vista Glass Effect enabled for Ribbon Bar.
//-----------------------------------------------------------------------
BOOL IsDwmEnabled() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to set custom font height for ribbon bar
// Parameters:
// nFontHeight - Font height to set
//-----------------------------------------------------------------------
void SetFontHeight(int nFontHeight);
//-----------------------------------------------------------------------
// Summary:
// Determines font height used for Ribbon Bar
//-----------------------------------------------------------------------
int GetFontHeight() const;
//-----------------------------------------------------------------------
// Summary:
// Determines if caption part of ribbon is visible
//-----------------------------------------------------------------------
BOOL IsCaptionVisible() const;
//-----------------------------------------------------------------------
// Summary:
// This method allow show/hide caption if frame theme is not enabled.
// Parameters:
// bShowCaption - TRUE to show caption if frame theme is not enabled.
//-----------------------------------------------------------------------
void ShowCaptionAlways(BOOL bShowCaption);
//-----------------------------------------------------------------------
// Summary:
// Call this member function to get the size of a toolbar icon.
// See Also:
// GetLargeIconSize
//-----------------------------------------------------------------------
virtual CSize GetIconSize() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to get pointer to quick access button
// Returns:
// Pointer to quick access button
//-----------------------------------------------------------------------
CXTPControl* GetControlQuickAccess() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to determin if cues are visible
// Returns:
// True if visible, False otherwise.
//-----------------------------------------------------------------------
BOOL IsKeyboardCuesVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Reset the ribbon\quick access toolbar
// Parameters:
// bShowWarningMessage - True to show warning message box to user.
//-----------------------------------------------------------------------
void Reset(BOOL bShowWarningMessage);
BOOL IsBackstageViewVisible() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to set icon id that will be used if user add new control to quick access without icon
// Parameters:
// nIconId - Icon will be associated with new quick access control.
//-----------------------------------------------------------------------
void SetQuickAccessEmptyIconId(int nIconId);
protected:
//-----------------------------------------------------------------------
// Summary:
// This virtual method called when tab is about to be changed.
// Parameters:
// pTab - Tab to be selected
// Returns:
// returns TRUE to cancel tab changing, FALSE to allow.
//-----------------------------------------------------------------------
virtual BOOL OnTabChanging(CXTPRibbonTab* pTab);
//-----------------------------------------------------------------------
// Summary:
// This virtual method called when current tab is changed.
// Parameters:
// pTab - New selected tab
//-----------------------------------------------------------------------
virtual void OnTabChanged(CXTPRibbonTab* pTab);
virtual CXTPRibbonTabPopupToolBar* CreateTabPopupToolBar(CXTPRibbonTab* pTab);
BOOL IsControlEnabled(const CXTPControl* pControl) const;
//{{AFX_CODEJOCK_PRIVATE
protected:
//-----------------------------------------------------------------------
// Summary:
// This method is called to assign self identifiers for serialization process.
// Parameters:
// nID - Identifier to assign
// pCommandBarList - List of CommandBars.
// pParam - Address of a XTP_COMMANDBARS_PROPEXCHANGE_PARAM structure.
//-----------------------------------------------------------------------
void GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam);
//-----------------------------------------------------------------------
// Summary:
// This method is called in serialization process.to restore popups from list of command bars.
// Parameters:
// pCommandBarList - List of CommandBars.
//-----------------------------------------------------------------------
void RestoreCommandBarList(CXTPCommandBarList* pCommandBarList);
void DoPropExchange(CXTPPropExchange* pPX);
void Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive = FALSE);
virtual CXTPPopupBar* CreateContextMenu(CXTPControl* pSelectedControl);
virtual CXTPPopupBar* CreateMoreQuickAccessContextMenu();
virtual BOOL ShouldSerializeBar();
virtual void MergeToolBar(CXTPCommandBar* pCommandBar, BOOL bSilent);
int HitTestCaption(CPoint point) const;
void RepositionCaptionButtons();
void RepositionContextHeaders();
void AddCaptionButton(int nId, BOOL bAdd, BOOL bEnabled, CRect& rcCaption);
BOOL ShrinkContextHeaders(int nLeft, int nRight);
void ShowContextMenu(CPoint point, CXTPControl* pSelectedControl);
virtual void CreateKeyboardTips();
virtual void OnKeyboardTip(CXTPCommandBarKeyboardTip* pTip);
virtual void OnCustomizeDrop(CXTPControl* pDataObject, DROPEFFECT& dropEffect, CPoint ptDrop, CPoint ptDrag);
void RefreshSysButtons();
virtual BOOL ProcessSpecialKey(XTPSpecialKey key);
protected:
public:
virtual CSize CalcDockingLayout(int nLength, DWORD dwMode, int nWidth = 0);
void Reposition(int cx, int cy);
void RepositionGroups(CDC* pDC, CRect rcGroups);
virtual BOOL PreviewAccel(UINT chAccel);
//-----------------------------------------------------------------------
// Summary:
// Call this member to change the tracking state.
// Parameters:
// bMode - TRUE to set the tracking mode; otherwise FALSE.
// bSelectFirst - TRUE to select the first item.
// bKeyboard - TRUE if the item is popuped by the keyboard.
// Returns:
// TRUE if the method was successful.
//-----------------------------------------------------------------------
virtual BOOL SetTrackingMode(int bMode, BOOL bSelectFirst = TRUE, BOOL bKeyboard = FALSE);
int OnHookMessage(HWND /*hWnd*/, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& /*lResult*/);
void OnRemoved();
void OnGroupsScroll(BOOL bScrollLeft);
int GetRibbonTopBorder() const;
void CustomizeFindDropIndex(CXTPControl* pDataObject, const CPoint& point, CRect& rcMarker, int& nDropIndex, BOOL& bDropAfter);
//}}AFX_CODEJOCK_PRIVATE
protected:
//{{AFX_CODEJOCK_PRIVATE
DECLARE_MESSAGE_MAP()
//{{AFX_VIRTUAL(CXTPRibbonBar)
//}}AFX_VIRTUAL
//{{AFX_MSG(CXTPRibbonBar)
afx_msg void OnMouseLeave();
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg INT_PTR OnToolHitTest(CPoint point, TOOLINFO* pTI) const;
afx_msg void OnSysColorChange();
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
void OnPopupRButtonUp(CXTPCommandBar* pCommandBar, CPoint point);
afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
afx_msg void OnCustomizePlaceQuickAccess(UINT nCommand);
afx_msg LRESULT OnCustomizeCommand(WPARAM wParam, LPARAM lParam);
afx_msg LRESULT OnNcHitTest(CPoint point);
//}}AFX_MSG
//}}AFX_CODEJOCK_PRIVATE
protected:
protected:
CRect m_rcTabControl; // Bounding rectangle of Tabs
CRect m_rcGroups; // Groups bounding rectangle
CRect m_rcCaption; // Caption bounding rectangle
CRect m_rcCaptionText; // Caption text bounding rectangle
CRect m_rcHeader; // Header bounding rectangle
CRect m_rcQuickAccess; // Quick access bounding rectangle
BOOL m_bRibbonBarVisible; // TRUE if ribbon bar visible
BOOL m_bGroupsVisible; // TRUE if groups is visible
BOOL m_bTabsVisible; // TRUE if tabs are visible
BOOL m_bShowQuickAccessBelow; // TRUE to show quick access controls below ribbon bar
BOOL m_bShowQuickAccess; // TRUE to show quick access
BOOL m_bAllowQuickAccessDuplicates; // TRUE to allow quick access duplicates
BOOL m_bAllowQuickAccessCustomization; // TRUE to allow quick access customization
BOOL m_bGroupReducedChanged; // Some group appear in resize handler
int m_nQuickAccessHeight; // Quick Access height
BOOL m_bAllowMinimize; // TRUE to allow minimize ribbon
CXTPRibbonQuickAccessControls* m_pQuickAccessControls; // Quick AccessControls (not used now)
CXTPRibbonControlTab* m_pControlTab; // Control tab pointer
CXTPControl* m_pControlQuickAccess; // Quick Access menu control
CXTPControl* m_pControlQuickAccessMore; // Quick Access more control
CXTPRibbonControlSystemButton* m_pControlSystemButton; // System button control
BOOL m_bMinimizeOnDblClick; // True to allow the ribbon to be minimized\maximized when double clicked
int m_nMinVisibleWidth; // Minimum width before ribbon bar disappears
int m_nMinVisibleHeight; // Minimum height before ribbon bar disappears
CXTPRibbonTabContextHeaders* m_pContextHeaders; // Context header collection
int m_nGroupsHeight; // Custom groups height
int m_nClientHeight; // Custom groups height
BOOL m_bMinimized; // TRUE if Ribbon currently minimized
BOOL m_bShowCaptionAlways; // TRUE to show caption even if EnableFrameTheme was not called.
CString m_strCaptionText; // Caption text
int m_nQuickAccessEmptyIconId;
private:
friend class CXTPRibbonControlTab;
friend class CXTPRibbonBarControlQuickAccessPopup;
friend class CControlQuickAccessMorePopup;
friend class CXTPRibbonGroup;
friend class CXTPRibbonControls;
friend class CXTPRibbonGroups;
friend class CXTPRibbonTabPopupToolBar;
};
AFX_INLINE CRect CXTPRibbonBar::GetTabControlRect() const {
return m_rcTabControl;
}
AFX_INLINE CXTPRibbonGroup* CXTPRibbonBar::GetHighlightedGroup() const {
return m_pHighlightedGroup;
}
AFX_INLINE CXTPRibbonGroup* CXTPRibbonScrollableBar::GetHighlightedGroup() const {
return m_pHighlightedGroup;
}
AFX_INLINE CXTPRibbonControlTab* CXTPRibbonBar::GetControlTab() const {
return m_pControlTab;
}
AFX_INLINE void CXTPRibbonBar::SetMinimumVisibleWidth(int nMinVisibleWidth) {
m_nMinVisibleWidth = nMinVisibleWidth;
}
AFX_INLINE void CXTPRibbonBar::SetMinimumVisibleSize(int nMinVisibleWidth, int nMinVisibleHeight ) {
m_nMinVisibleWidth = nMinVisibleWidth;
m_nMinVisibleHeight = nMinVisibleHeight;
}
AFX_INLINE int CXTPRibbonBar::GetMinimumVisibleWidth() const {
return m_nMinVisibleWidth;
}
AFX_INLINE CRect CXTPRibbonBar::GetCaptionRect() const {
return m_rcCaption;
}
AFX_INLINE CRect CXTPRibbonBar::GetCaptionTextRect() const {
return m_rcCaptionText;
}
AFX_INLINE CRect CXTPRibbonBar::GetQuickAccessRect() const {
return m_rcQuickAccess;
}
AFX_INLINE CXTPRibbonQuickAccessControls* CXTPRibbonBar::GetQuickAccessControls() const {
return m_pQuickAccessControls;
}
AFX_INLINE CXTPRibbonControlSystemButton* CXTPRibbonBar::GetSystemButton() const {
return m_pControlSystemButton;
}
AFX_INLINE BOOL CXTPRibbonBar::IsRibbonBarVisible() const {
return m_bVisible && m_bRibbonBarVisible;
}
AFX_INLINE CXTPRibbonTabContextHeaders* CXTPRibbonBar::GetContextHeaders() const {
return m_pContextHeaders;
}
AFX_INLINE BOOL CXTPRibbonBar::IsRibbonBar() const {
return TRUE;
}
AFX_INLINE void CXTPRibbonBar::ShowQuickAccess(BOOL bShow) {
m_bShowQuickAccess = bShow;
OnRecalcLayout();
}
AFX_INLINE BOOL CXTPRibbonBar::IsQuickAccessVisible() const {
return m_bShowQuickAccess;
}
AFX_INLINE void CXTPRibbonBar::AllowQuickAccessDuplicates(BOOL bAllow) {
m_bAllowQuickAccessDuplicates = bAllow;
}
AFX_INLINE void CXTPRibbonBar::AllowQuickAccessCustomization(BOOL bAllow) {
m_bAllowQuickAccessCustomization = bAllow;
}
AFX_INLINE BOOL CXTPRibbonBar::IsAllowQuickAccessDuplicates() const {
return m_bAllowQuickAccessDuplicates;
}
AFX_INLINE void CXTPRibbonBar::SetGroupsHeight(int nHeight) {
m_nGroupsHeight = nHeight;
}
AFX_INLINE void CXTPRibbonBar::AllowMinimize(BOOL bAllow) {
m_bAllowMinimize = bAllow;
}
AFX_INLINE CRect CXTPRibbonBar::GetGroupsRect() const {
return m_rcGroups;
}
AFX_INLINE void CXTPRibbonBar::ShowCaptionAlways(BOOL bShowCaption) {
m_bShowCaptionAlways = bShowCaption;
}
AFX_INLINE CXTPControl* CXTPRibbonBar::GetControlQuickAccess() const {
return m_pControlQuickAccess;
}
AFX_INLINE void CXTPRibbonBar::SetQuickAccessEmptyIconId(int nIconId) {
m_nQuickAccessEmptyIconId = nIconId;
}
#endif // !defined(__XTPRIBBONBAR_H__)