// 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__)