// XTPCommandBars.h : interface for the CXTPCommandBars class. // // This file is a part of the XTREME COMMANDBARS 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(__XTPCOMMANDBARS_H__) #define __XTPCOMMANDBARS_H__ //}}AFX_CODEJOCK_PRIVATE #if _MSC_VER >= 1000 #pragma once #endif // _MSC_VER >= 1000 class CXTPDockBar; class CXTPToolBar; class CXTPControl; class CXTPPopupBar; class CXTPDockState; class CXTPCommandBar; class CXTPCustomizeDropSource; class CXTPCommandBars; class CXTPCommandBarList; class CXTPImageManager; class CXTPPaintManager; class CXTPControls; class CXTPMenuBar; class CXTPReBar; class CXTPToolTipContext; class CXTPShortcutManager; class CXTPKeyboardManager; class CXTPStatusBar; class CXTPMouseManager; class CXTPControlActions; class CXTPControlAction; class CXTPPropExchange; class CXTPCommandBarsFrameHook; class CXTPRecentFileList; //=========================================================================== // Summary: // CXTPCommandBarKeyboardTip is CWnd derived class, represents Keyboard tip single window //=========================================================================== class _XTP_EXT_CLASS CXTPCommandBarKeyboardTip : public CWnd { public: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPCommandBarKeyboardTip object // Parameters: // pCommandBars - CXTPCommandBars parent object // pOwner - Owner object // lpszCaption - Caption of control // pt - Client coordinates // dwAlign - Align of tip // bEnabled - TRUE if keyboard tip is enabled //----------------------------------------------------------------------- CXTPCommandBarKeyboardTip(CXTPCommandBars* pCommandBars, CCmdTarget* pOwner, LPCTSTR lpszCaption, CPoint pt, DWORD dwAlign, BOOL bEnabled); protected: //{{AFX_CODEJOCK_PRIVATE DECLARE_MESSAGE_MAP() afx_msg void OnPaint(); afx_msg LRESULT OnNcHitTest(CPoint point); //}}AFX_CODEJOCK_PRIVATE public: CString m_strTip; // Tooltip CString m_strCaption; // Caption CString m_strPrefix; // Caption CCmdTarget* m_pOwner; // Owner object CPoint m_pt; // Client coordinates BOOL m_bEnabled; // Enabled flag BOOL m_bVisible; // TRUE if visible CXTPCommandBars* m_pCommandBars; // Parent CXTPCommandBars object DWORD m_dwAlign; // Tip align BOOL m_bExplicit; // TRUE when user specify manually KeyTip; FALSE if calculated automatically }; //=========================================================================== // Summary: // CXTPCommandBarList is a CList derived class. It is used as a collection // of CXTPCommandBar classes. //=========================================================================== class _XTP_EXT_CLASS CXTPCommandBarList : public CXTPCmdTarget { public: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPCommandBarList object // Parameters: // pCommandBars - Parent CXTPCommandBars pointer //----------------------------------------------------------------------- CXTPCommandBarList(CXTPCommandBars* pCommandBars) { m_pCommandBars = pCommandBars; } //----------------------------------------------------------------------- // Summary: // Destroys a CXTPCommandBarList object, handles cleanup and // deallocation //----------------------------------------------------------------------- virtual ~CXTPCommandBarList(); public: //----------------------------------------------------------------------- // Summary: // Call this member to find the CommandBar with the specified // identifier. // Parameters: // nBarID - Identifier CommandBar to find. // Returns: // A pointer to a CXTPCommandBar object. //----------------------------------------------------------------------- CXTPCommandBar* FindCommandBar(UINT nBarID) const; //----------------------------------------------------------------------- // Summary: // Returns Commandbars object attached to list // Returns: // Pointer to CXTPCommandBars parent object // See Also: // CXTPCommandBars, CXTPCommandBar //----------------------------------------------------------------------- CXTPCommandBars* GetCommandBars() const { return m_pCommandBars; } //----------------------------------------------------------------------- // Summary: // Returns CommandBar in list by its index // Parameters: // nIndex - Index of the commandbar to return // Returns: // CommandBar in list by its index // See Also: GetCount //----------------------------------------------------------------------- CXTPCommandBar* GetAt(int nIndex) const; //----------------------------------------------------------------------- // Summary: // Return count of commanbars in list // Returns: // Commanbars count // See Also: GetAt //----------------------------------------------------------------------- int GetCount() const; //----------------------------------------------------------------------- // Summary: // Call this method to add new commandbar to the list // Parameters: // pCommandBar - CommandBar to be added // Returns: // Pointer to just added CommandBar // See Also: GetAt, GetCount //----------------------------------------------------------------------- virtual CXTPCommandBar* Add(CXTPCommandBar* pCommandBar); //----------------------------------------------------------------------- // Summary: // Call this method to check if CommandBar exists in the list // Parameters: // pCommandBar - CommandBar to test // Returns: // TRUE if CommandBar exists in the list //----------------------------------------------------------------------- BOOL Lookup(CXTPCommandBar* pCommandBar) const; //------------------------------------------------------------------------- // Summary: // Call this method to clean the list // See Also: Remove //------------------------------------------------------------------------- void RemoveAll(); //----------------------------------------------------------------------- // Summary: // Call this method to remove CommandBar from the list // Parameters: // pCommandBar - CommandBar to be removed // See Also: RemoveAll //----------------------------------------------------------------------- void Remove(CXTPCommandBar* pCommandBar); protected: CXTPCommandBars* m_pCommandBars; // Parent CXTPCommandBars object CArray m_arrBars; // Array of CommandBars }; //=========================================================================== // Summary: // CXTPCommandBarsContextMenus is CXTPCommandBarList derived class, // represents collection of context menus //=========================================================================== class _XTP_EXT_CLASS CXTPCommandBarsContextMenus : public CXTPCommandBarList { public: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPCommandBarsContextMenus object // Parameters: // pCommandBars - Parent CXTPCommandBars object //----------------------------------------------------------------------- CXTPCommandBarsContextMenus(CXTPCommandBars* pCommandBars); public: //----------------------------------------------------------------------- // Summary: // Call this method to add new context menu to collection // Parameters: // nIDBar - Menu resource identifier // pCommandBar - CommandBar to be added // lpszTitle - Caption of context menu // pSubMenu - Context menu to convert // nSubMenu - Index of submenu to add // Returns: // Pointer to added context menu. //----------------------------------------------------------------------- CXTPCommandBar* Add(UINT nIDBar); CXTPCommandBar* Add(UINT nIDBar, UINT nIDMenuResource, int nSubMenu); // CXTPCommandBar* Add(CXTPCommandBar* pCommandBar); // CXTPCommandBar* Add(UINT nIDBar, LPCTSTR lpszTitle, CMenu* pSubMenu); // //{{AFX_CODEJOCK_PRIVATE //}}AFX_CODEJOCK_PRIVATE }; //----------------------------------------------------------------------- // Summary: // XTP_COMMANDBARS_PROPEXCHANGE_PARAM is a // structure used to store the CommandBar's save settings. This is // a set of State options that will be used to change how and what // will be saved and loaded when loading and saving XML files. // Remarks: // When saving your XML string to a file, be sure to use the .XML // file extension. If you open up your .XML file in your favorite // web browser it will automatically format the XML string into the // correct format. // See Also: CXTPCommandBars::DoPropExchange, CXTPPropExchangeXMLNode // Example: // // XTP_COMMANDBARS_PROPEXCHANGE_PARAM param; // param.bSerializeControls = TRUE; // // Serialize to XML // CXTPPropExchangeXMLNode px(FALSE, 0, _T("Settings")); // CXTPPropExchangeSection pxCommandBars(px.GetSection(_T("CommandBars"))); // GetCommandBars()->DoPropExchange(&pxCommandBars, ¶m); // px.SaveToFile(m_strIniFileName); // //----------------------------------------------------------------------- struct XTP_COMMANDBARS_PROPEXCHANGE_PARAM { //{{AFX_CODEJOCK_PRIVATE //------------------------------------------------------------------------- // Summary: // Creates a XTP_COMMANDBARS_PROPEXCHANGE_PARAM object which is a // structure used to store the CommandBar's save settings. This is // a set of State options that will be used to change how and what // will be saved and loaded when loading and saving XML files. // The CXTPPropExchangeXMLNode class is used to create the XML file. // Remarks: // When saving your XML string to a file, be sure to use the .XML // file extension. If you open up your .XML file in your favorite // web browser it will automatically format the XML string into the // correct format. // See Also: CXTPCommandBars::DoPropExchange, CXTPPropExchangeXMLNode //------------------------------------------------------------------------- XTP_COMMANDBARS_PROPEXCHANGE_PARAM() { pCommandBars = NULL; bSerializeControls = FALSE; bSaveOnlyCustomized = TRUE; bLoadSilent = FALSE; bSaveOriginalControls = TRUE; bSerializeLayout = TRUE; bSerializeOptions = FALSE; bSerializeImages = FALSE; bSerializeDesignerControls = FALSE; bSerializeActions = FALSE; } //}}AFX_CODEJOCK_PRIVATE BOOL bSerializeControls; // If True, the controls in the CommandBars will be saved. If False, no controls will be saved, // regardless of the other settings. The default is True BOOL bSaveOnlyCustomized ; // If True, only CommandBars that have been customized will be saved. The default is True BOOL bLoadSilent; // If True, no message boxes will be displayed when the CommandBar layout is loaded. // i.e. The message box that asks for conformation before the CommandBar layout is reset. BOOL bSaveOriginalControls; // If True, the original state of the CommandBars is saved along with the customized state // For example, if a button on a toolbar is moved, then both the original and modified states will be saved. // The Default is True BOOL bSerializeImages; // If True, the images stored in the ImageManager will be saved. The default is False BOOL bSerializeOptions; // If True, the setting on the Keyboard and Options pages of the Customize dialog will // be saved. This includes shortcut keys and CommandBar options like large icons and full menus. // The default is False BOOL bSerializeLayout; // If True, the layout of the CommandBars will be saved. The Layout includes information such as bar position, location, and size. The Default is True BOOL bSerializeDesignerControls; // In the CommandBar Designer you can export a XCB file to a XML file and Load it in your project. // If SerializeDesignerControls is True, then the DesignerControls property will be filled with // Control items from the CommandBar Designer's controls pane. This allows you to load the XML file instead // of loading the XCB file using the LoadDesignerBars method. NOTE: DesignerControls are the controls displayed in the customization dialog. // The CXTPPropExchangeXMLNode class is used to create the XML file. // The default is False BOOL bSerializeActions; // TRUE to save/restore actions for commandbars CXTPCommandBars* pCommandBars; // Pointer to the CommandBars object that the XTP_COMMANDBARS_PROPEXCHANGE_PARAM setting apply to. }; //=========================================================================== // Summary: // Options of the command bars. // See Also: // CXTPCommandBars::GetCommandBarsOptions // Example: // pCommandBars->GetCommandBarsOptions()->animationType = xtpAnimateFade; //=========================================================================== class _XTP_EXT_CLASS CXTPCommandBarsOptions : public CXTPCmdTarget { public: //----------------------------------------------------------------------- // Summary: // Constructs an CXTPCommandBarsOptions object //----------------------------------------------------------------------- CXTPCommandBarsOptions(); public: //----------------------------------------------------------------------- // Summary: // Reads or writes options from or to an archive. // Parameters: // ar - A CArchive object to serialize to or from. //----------------------------------------------------------------------- void Serialize(CArchive& ar); //----------------------------------------------------------------------- // Summary: // Reads or writes options from or to an archive. // Parameters: // pPX - A CXTPPropExchange object to serialize to or from. // bUserOptionsOnly - TRUE to serialize user's options only. //----------------------------------------------------------------------- void DoPropExchange(CXTPPropExchange* pPX, BOOL bUserOptionsOnly = FALSE); //----------------------------------------------------------------------- // Summary: // Call this method to enable/disble menu underlines. // Parameters: // keyboardCues - determines if menu underlines is enabled. // Remarks: // keyboardCues parameter can be one of the following: // * xtpKeyboardCuesShowAlways - Show keyboard cues always // * xtpKeyboardCuesShowNever - Show keyboard cues always // * xtpKeyboardCuesShowWindowsDefault - System defined //----------------------------------------------------------------------- void ShowKeyboardCues(XTPKeyboardCuesShow keyboardCues); //----------------------------------------------------------------------- // Summary: // Call this method to get menu underlines state // Returns: // Returns one of the following: // * xtpKeyboardCuesShowAlways - Show keyboard cues always // * xtpKeyboardCuesShowNever - Show keyboard cues always // * xtpKeyboardCuesShowWindowsDefault - System defined //----------------------------------------------------------------------- XTPKeyboardCuesShow GetShowKeyboardCues() const; public: BOOL bAlwaysShowFullMenus; // TRUE to show full menus always. BOOL bShowFullAfterDelay; // TRUE to show full menus after short delay. BOOL bToolBarScreenTips; // TRUE to show toolbar's tooltips BOOL bToolBarAccelTips; // TRUE to add accelerators to tooltips. BOOL bLargeIcons; // TRUE to use large toolbars icons. BOOL bSyncFloatingBars; // TRUE to hide floating bars when site frame deactivated. BOOL bShowExpandButtonAlways; // TRUE to show expand buttons always. BOOL bDblClickFloat; // TRUE to make toolbar floating be double-clicking. BOOL bShowTextBelowIcons; // TRUE to show captions below icons. BOOL bAltDragCustomization; // Allows users to change a toolbar button's position by dragging it while holding down ALT. BOOL bAutoHideUnusedPopups; // TRUE to hide unused popup controls. This is similar to how the Windows Start menu hides infrequently used popups. BOOL bDirtyState; // TRUE if the user has done any type of customization to menus or toolbars. (I.e. Moving a toolbar or adding a new button). After a load or save of the BarStae this is set to FALSE. BOOL bShowPopupBarToolTips; // TRUE to display ToolTips for controls in popup menus. BOOL bShowContextMenuAccelerators; // TRUE to show accelerators in contect menus. XTPAnimationType animationType; // Animation type. BOOL bAutoUpdateShortcuts; // TRUE to update shortcuts from accelerator table DWORD keyboardCuesUse; // Keyboard cues using BOOL bFlyByStatus; // Status bar displays information about the button CSize szIcons; // Size of the normal icons. CSize szLargeIcons; // Size of the large icons. CSize szPopupIcons; // Size of icons displayed in popup menus. BOOL bUseAltNumPadKeys; // TRUE to allow activate menu with Alt + num pad key. BOOL bUseSystemSaveBitsStyle; // TRUE to use CS_SAVEBITS class style for popups and shadows BOOL bDisableCommandIfNoHandler; // TRUE to disable commands if no handler presented BOOL bWrapLargePopups; // Wrap controls for large popups instead scroll them. CMap m_mapHiddenCommands; // Hidden command array. CMap m_mapUsedCommands; // Used commands array. BOOL bShowKeyboardTips; // TRUE to use keyboard tips. private: CXTPCommandBars* m_pCommandBars; XTPKeyboardCuesShow keyboardCuesShow; friend class CXTPCommandBars; }; //=========================================================================== // Summary: // CXTPCommandBars is standalone class. It allows developer manipulate // toolbars and popupbars // See Also: CXTPCommandBar, CXTPToolBar, CXTPCommandBarsOptions //=========================================================================== class _XTP_EXT_CLASS CXTPCommandBars : public CXTPCmdTarget { protected: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPCommandBars object //----------------------------------------------------------------------- CXTPCommandBars(); //----------------------------------------------------------------------- // Summary: // Destroys a CXTPCommandBars object, handles cleanup and deallocation //----------------------------------------------------------------------- virtual ~CXTPCommandBars(); public: //----------------------------------------------------------------------- // Summary: // Call this member to create menu bar. // Parameters: // lpszName - Title of menu bar. // nID - menu identifier to be loaded. // Returns: // A CXTPMenuBar object if successful; otherwise NULL. // See Also: Add //----------------------------------------------------------------------- CXTPMenuBar* SetMenu(LPCTSTR lpszName, UINT nID); //----------------------------------------------------------------------- // Summary: // Call this member to add a new toolbar. // Parameters: // lpszName - Title of toolbar. // nBarPosition - Position of toolbar to be created. // pToolbarClass - Runtime class of toolbar to create // Remarks: // CommandBars will create new toolbar with pToolbarClass runtime class if it specified, // if not m_pToolBarClass will be used.

// Call SetToolBarClass to set default runtime class for toolbars. // Returns: // A CXTPToolBar object if successful; otherwise NULL. // See Also: SetMenu, SetToolBarClass //----------------------------------------------------------------------- CXTPToolBar* Add(LPCTSTR lpszName, XTPBarPosition nBarPosition, CRuntimeClass* pToolbarClass = NULL); CXTPToolBar* Add(CXTPToolBar* pToolBar, LPCTSTR strName, XTPBarPosition nBarPosition); //----------------------------------------------------------------------- // Summary: // Call this member to get the active menu bar. // Returns: // A CXTPMenuBar pointer associated with the menu bar. //----------------------------------------------------------------------- virtual CXTPMenuBar* GetMenuBar() const; //----------------------------------------------------------------------- // Summary: // Call this member to get the toolbar with the specified identifier. // Parameters: // nID - An integer identifier. // Returns: // The CXTPToolBar pointer //----------------------------------------------------------------------- CXTPToolBar* GetToolBar(UINT nID) const; //----------------------------------------------------------------------- // Summary: // Call this member to get the site of the command bars. // Returns: // A CFrameWnd pointer representing the site of the command bars. //----------------------------------------------------------------------- CWnd* GetSite() const; //----------------------------------------------------------------------- // Summary: // Call this member to get the dock bar at the specified position. // Parameters: // barPosition - Position of the dockbar. // Returns: // A CXTPDockBar pointer. //----------------------------------------------------------------------- CXTPDockBar* GetDockBar(XTPBarPosition barPosition) const; //----------------------------------------------------------------------- // Summary: // Call this member to redraw the command bars. //----------------------------------------------------------------------- void RedrawCommandBars(); //----------------------------------------------------------------------- // Summary: // Call this member to invalidate the command bars. //----------------------------------------------------------------------- void InvalidateCommandBars(); //----------------------------------------------------------------------- // Summary: // Call this member to recalculate site layout. // Parameters: // bDelay - TRUE to delay dock site layout until remaining framework // items have been initialized completely. //----------------------------------------------------------------------- virtual void RecalcFrameLayout(BOOL bDelay = FALSE); //----------------------------------------------------------------------- // Summary: // Call this member to find the specified control. // Parameters: // type - Type of the control to find. // nId - Control's identifier. // bVisible - Control is visible. // bRecursive - To find in the nested command bars. // Returns: // The CXTPControl object if successful; otherwise NULL. //----------------------------------------------------------------------- CXTPControl* FindControl(XTPControlType type, UINT nId, BOOL bVisible, BOOL bRecursive) const; // ----------------------------------------------------------------------------- // Summary: // Call this member to display a floating pop-up menu at the // specified location. // Parameters: // pMenu : Menu to be popped up. // nFlags : Reserved, currently not used. // xPos : Specifies the horizontal position in screen coordinates // of the popup menu. // yPos : Specifies the vertical position in screen coordinates of // the top of the menu on the screen. // pWnd : Identifies the window that owns the popup menu. This // window receives all WM_COMMAND messages from the menu. // rcExclude : Reserved, currently not used. // pWndOwner : Points to a CWnd object // pCommandBars : Points to a CXTPCommandBars object. // pPopupBar : Points to a CXTPPopupBar object. // nBarID : Identifier CommandBar to track. // lptpm : Pointer to a TPMPARAMS structure that specifies an area of the screen the menu should not overlap. This parameter can be NULL. // Returns: // TRUE if successful; otherwise returns FALSE // Example: // // void CCustomThemesView::OnRButtonDown(UINT /*nFlags*/, CPoint point) // { // ClientToScreen(&point); // // CMenu menu; // VERIFY(menu.LoadMenu(IDR_MAINFRAME)); // // // get a pointer to the application window. // CXTPMDIFrameWnd* pMainWnd = DYNAMIC_DOWNCAST( // CXTPMDIFrameWnd, AfxGetMainWnd()); // // if (!pMainWnd) // return; // // // get a pointer to the CXTPCommandBars object. // CXTPCommandBars* pCommandBars = pMainWnd-\>GetCommandBars(); // // if (!pCommandBars) // return; // // // display context menu. // CXTPCommandBars::TrackPopupMenu(&menu, TPM_RIGHTBUTTON, // point.x, point.y, pMainWnd, 0, 0, pCommandBars); // } // // ----------------------------------------------------------------------------- static BOOL AFX_CDECL TrackPopupMenu(CMenu* pMenu, UINT nFlags, int xPos, int yPos, CWnd* pWnd, LPCRECT rcExclude = NULL, CWnd* pWndOwner = NULL, CXTPCommandBars* pCommandBars = NULL); static BOOL AFX_CDECL TrackPopupMenu(CXTPPopupBar* pPopupBar, UINT nFlags, int xPos, int yPos, CWnd* pWnd, LPCRECT rcExclude = NULL, CWnd* pWndOwner = NULL); // BOOL TrackPopupMenu(UINT nBarID, UINT nFlags, int xPos, int yPos, LPCRECT rcExclude = NULL); // BOOL TrackPopupMenuEx(CMenu* pMenu, UINT nFlags, int xPos, int yPos, CWnd* pWndOwner = NULL, LPTPMPARAMS lptpm = NULL);// //----------------------------------------------------------------------- // Summary: // Retrieves list of available context menus // Returns: // Command Bars context menus. //----------------------------------------------------------------------- CXTPCommandBarsContextMenus* GetContextMenus() const; //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the options of the command bars. // Returns: // Command Bars options. //----------------------------------------------------------------------- CXTPCommandBarsOptions* GetCommandBarsOptions() const; //----------------------------------------------------------------------- // 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. // bOnlyCustomized - TRUE to save only the state for customized // command bar items. // See Also: LoadBarState, DoPropExchange //----------------------------------------------------------------------- void SaveBarState(LPCTSTR lpszProfileName, BOOL bOnlyCustomized = TRUE); //----------------------------------------------------------------------- // 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. // bSilent - TRUE to disable user notifications when command bars are restore to their original state. // See Also: SaveBarState, DoPropExchange //----------------------------------------------------------------------- void LoadBarState(LPCTSTR lpszProfileName, BOOL bSilent = FALSE); //----------------------------------------------------------------------- // Summary: // Call this function to save the command bars options. // 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. // See Also: LoadOptions, DoPropExchange //----------------------------------------------------------------------- void SaveOptions(LPCTSTR lpszProfileName); //----------------------------------------------------------------------- // Summary: // Call this function to restore the options of the command bars. // 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. // See Also: SaveOptions, DoPropExchange //----------------------------------------------------------------------- void LoadOptions(LPCTSTR lpszProfileName); //----------------------------------------------------------------------- // Summary: // Call this function to either read or write command bars from // or to an archive. // Parameters: // ar - A CArchive object to serialize to or from. // bSerializeControls - TRUE to store controls information. // bOnlyCustomized - TRUE to store each commandbar only if it was customized by user. // bSilent - TRUE to disable user notifications when command bars are restore to their original state. // See Also: DoPropExchange //----------------------------------------------------------------------- void SerializeBarState(CArchive& ar, BOOL bSerializeControls = FALSE, BOOL bOnlyCustomized = TRUE, BOOL bSilent = FALSE); //----------------------------------------------------------------------- // Summary: // Call this function to get ShortcutManager class pointer // Returns: // Pointer to current shortcut manager. // See Also: SetShortcutManager //----------------------------------------------------------------------- CXTPShortcutManager* GetShortcutManager() const; //----------------------------------------------------------------------- // Summary: // Call this function to set custom shortcut manager class. // Parameters: // pShortcutManager - New ShortcutManager to be set // See Also: GetShortcutManager //----------------------------------------------------------------------- void SetShortcutManager(CXTPShortcutManager* pShortcutManager); //----------------------------------------------------------------------- // Summary: // Reads or writes this object from or to an storage. // Parameters: // pPX - A CXTPPropExchange object to serialize to or from. // pParam - Exchange options. // Example: // // XTP_COMMANDBARS_PROPEXCHANGE_PARAM param; // param.bSerializeControls = TRUE; // // Serialize to XML // CXTPPropExchangeXMLNode px(FALSE, 0, _T("Settings")); // CXTPPropExchangeSection pxCommandBars(px.GetSection(_T("CommandBars"))); // GetCommandBars()->DoPropExchange(&pxCommandBars, ¶m); // px.SaveToFile(m_strIniFileName); // // See Also: CXTPPropExchange, XTP_COMMANDBARS_PROPEXCHANGE_PARAM //----------------------------------------------------------------------- void DoPropExchange(CXTPPropExchange* pPX, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam = NULL); //----------------------------------------------------------------------- // Summary: // Call this member function to load designer command bars from // an archive. // Parameters: // ar - A CArchive object to serialize to or from. // pPX - A CXTPPropExchange object to serialize to or from. //----------------------------------------------------------------------- void LoadDesignerBars(CArchive& ar); void LoadDesignerBars(CXTPPropExchange* pPX); // //# Intelligent menus routines //----------------------------------------------------------------------- // Summary: // This member function adds the specified commands to the list of // menu items to hide until activated by clicking on the chevron. // Parameters: // pCommands - An array of command IDs, of menu items, to hide. // nCount - Size of the array passed in. // Remarks: // The command will not be displayed in popup menus until the user // clicks on the "expand menu" chevron or after a short delay when // bShowFullAfterDelay is TRUE. Note: bAlwaysShowFullMenus must set // to FALSE to hide the hidden commands //----------------------------------------------------------------------- void HideCommands(const UINT* pCommands, int nCount); //----------------------------------------------------------------------- // Summary: // This member function adds the specified command to the list of // menu items to hide until activated by clicking on the chevron. // Parameters: // nCommand - The command ID of a menu item to hide. //----------------------------------------------------------------------- void HideCommand(UINT nCommand); //----------------------------------------------------------------------- // Summary: // Call this member function to retrieve if the command is hidden // until activated by clicking on the chevron. I.e. Infrequently // used commands. // Parameters: // nCommand - Command id to check. // Remarks: // The command will not be displayed in popup menus until the user // clicks on the "expand menu" chevron or after a short delay when // bShowFullAfterDelay is TRUE. Note: bAlwaysShowFullMenus must set // to FALSE to hide the hidden commands // Returns: // TRUE if the command item is hidden; otherwise returns FALSE. //----------------------------------------------------------------------- virtual BOOL IsCommandHidden(UINT nCommand); //----------------------------------------------------------------------- // Summary: // Call this member function to retrieve if the control is hidden and of type // CXTPControlPopup when bAutoHideUnusedPopups is TRUE. // Parameters: // pControl - Control pointer to check. // Remarks: // If bAutoHideUnusedPopups is FALSE, then this member performs the same // action as IsCommandHidden. Override this member to provide custom intelligent menu scheme. // Returns: // TRUE if the control item is hidden; otherwise returns FALSE. //----------------------------------------------------------------------- virtual BOOL IsControlHidden(CXTPControl* pControl); //----------------------------------------------------------------------- // Summary: // Call this member function to set the command activated by user. // Parameters: // nCommand - Command id to set //----------------------------------------------------------------------- void SetCommandUsed(UINT nCommand); //----------------------------------------------------------------------- // Summary: // Call this member function to restore the state of the hidden // commands. //----------------------------------------------------------------------- void ResetUsageData(); //----------------------------------------------------------------------- // Summary: // Retrieves active MDI document template // Returns: // Active document template identifier. //----------------------------------------------------------------------- virtual UINT GetActiveDocTemplate(); //----------------------------------------------------------------------- // Summary: // Call this member function to set the application's command bars into and out of print-preview mode. // Parameters: // bPreview - Specifies whether or not to place the application in print-preview mode. Set to TRUE to place in print preview, FALSE to cancel preview mode. //----------------------------------------------------------------------- void OnSetPreviewMode (BOOL bPreview); //------------------------------------------------------------------------- // Summary: // Sends WM_IDLEUPDATECMDUI message to all tool bars. //------------------------------------------------------------------------- void UpdateCommandBars() const; public: //----------------------------------------------------------------------- // Summary: // Determines if right-to-left mode was set. // Returns: // TRUE if text is displayed using right-to-left reading-order properties. //----------------------------------------------------------------------- BOOL IsLayoutRTL() 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); public: //----------------------------------------------------------------------- // Summary: // Call this method to process frame messages. // CXTPFrameWndBase derived classes call this method automatically. // Parameters: // pMsg - Points to an MSG object // Returns: // TRUE if the message was handled; otherwise FALSE. //----------------------------------------------------------------------- BOOL PreTranslateFrameMessage(MSG* pMsg); //----------------------------------------------------------------------- // Summary: // Call this method to process frame messages. // CXTPFrameWndBase derived classes call this method automatically. // Parameters: // message - Specifies the message to be sent. // wParam - Specifies additional message-dependent information. // lParam - Specifies additional message-dependent information. // pResult - The return value of WindowProc. Depends on the message; // may be NULL. // Returns: // TRUE if the message was handled; otherwise FALSE. //----------------------------------------------------------------------- BOOL OnFrameWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult); //----------------------------------------------------------------------- // Summary: // This method shows the context menu for toolbars. // Parameters: // pToolBar - Points to a CXTPToolBar object // point - Position of the menu to show. //----------------------------------------------------------------------- virtual void ContextMenu(CXTPToolBar* pToolBar, CPoint point); //----------------------------------------------------------------------- // Summary: // This method creates a context menu for toolbars. // Returns: // A CXTPPopupBar object containing list of toolbars. //----------------------------------------------------------------------- virtual CXTPPopupBar* GetToolbarsPopup(); //----------------------------------------------------------------------- // Summary: // Call this method to create an expand bar. // Parameters: // pToolBar - Points to a CXTPToolBar object // pExpandBar - Points to a CXTPCommandBar object //----------------------------------------------------------------------- virtual void GetHiddenControls(CXTPToolBar* pToolBar, CXTPCommandBar* pExpandBar); //----------------------------------------------------------------------- // Summary: // Call this method to create customized controls. // Parameters: // pToolBar - Points to a CXTPToolBar object // pExpandBar - Points to a CXTPCommandBar object //----------------------------------------------------------------------- virtual void GetAddOrRemovePopup(CXTPToolBar* pToolBar, CXTPCommandBar* pExpandBar); //----------------------------------------------------------------------- // Summary: // This method is called to set the site window. // Parameters: // pFrame - Points to a CWnd object //----------------------------------------------------------------------- void SetSite(CWnd* pFrame); //----------------------------------------------------------------------- // Summary: // Call this member to retrieve dock bar in specified point. // Parameters: // pt - Point needed to test. // pMainDock - CXTPDockBar class currently docked in. // Returns: // A pointer to a CXTPDockBar object. //----------------------------------------------------------------------- CXTPDockBar* CanDock(CPoint pt, CXTPDockBar* pMainDock = NULL) const; //----------------------------------------------------------------------- // Summary: // This member creates command bars. // Returns: // A pointer to a CXTPCommandBars object //----------------------------------------------------------------------- static CXTPCommandBars* AFX_CDECL CreateCommandBars(); //----------------------------------------------------------------------- // Summary: // This member is called to create dock bars. //----------------------------------------------------------------------- void EnableDocking(); //----------------------------------------------------------------------- // Summary: // Call this member to get toolbars count. // Returns: // Number of the toolbars. //----------------------------------------------------------------------- int GetCount() const; //----------------------------------------------------------------------- // Summary: // Call this member to retrieve a toolbar with the specified index. // Parameters: // nIndex - Index of the toolbar. // Returns: // A pointer to a CXTPToolBar object //----------------------------------------------------------------------- CXTPToolBar* GetAt(int nIndex) const; //----------------------------------------------------------------------- // Summary: // This method is called to activate toolbar. // Parameters: // pCommandBar - Toolbar to activate // bNext - TRUE to set foucs to the next toolbar. // Returns: // TRUE if successful; otherwise returns FALSE //----------------------------------------------------------------------- BOOL SetToolBarFocus(CXTPToolBar* pCommandBar, BOOL bNext = FALSE); //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the customize mode of the command // bars. // Returns: // TRUE if command bars in customize mode; otherwise returns FALSE //----------------------------------------------------------------------- BOOL IsCustomizeMode() const { return m_bCustomizeMode;} //----------------------------------------------------------------------- // Summary: // Call this member to set customize mode of the command bars. // Parameters: // bMode - TRUE to set customize mode. //----------------------------------------------------------------------- void SetCustomizeMode(BOOL bMode); //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the customize mode of the command // bars. // Returns: // TRUE if command bars in customize mode; otherwise returns FALSE // See Also: SetQuickCustomizeMode //----------------------------------------------------------------------- BOOL IsQuickCustomizeMode() const { return m_bQuickCustomizeMode;} //----------------------------------------------------------------------- // Summary: // Call this member to set customize mode of the command bars. // Parameters: // bMode - TRUE to set customize mode. // See Also: IsQuickCustomizeMode //----------------------------------------------------------------------- void SetQuickCustomizeMode(BOOL bMode); //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the CXTPCustomizeDropSource helper // class for customization. // Returns: // A pointer to a CXTPCustomizeDropSource object //----------------------------------------------------------------------- CXTPCustomizeDropSource* GetDropSource() const; //----------------------------------------------------------------------- // Summary: // This method is called when customized control changed. // Parameters: // pControl - Points to a CXTPControl object //----------------------------------------------------------------------- void SetDragControl(CCmdTarget* pControl); //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the current customized control. // Returns: // A pointer to a CXTPControl object //----------------------------------------------------------------------- CCmdTarget* GetDragControl() const; //----------------------------------------------------------------------- // Summary: // Call this member to retrieve if the customize is avail. // Returns: // TRUE if customize avail; otherwise returns FALSE //----------------------------------------------------------------------- BOOL IsCustomizeAvail() const; //----------------------------------------------------------------------- // Summary: // Call this member to disabled/enable customization. // Parameters: // bCustomizeAvail - TRUE to allow customization; FALSE to disable. //----------------------------------------------------------------------- void EnableCustomization(BOOL bCustomizeAvail); //----------------------------------------------------------------------- // Summary: // Call this member to remove the toolbar. // Parameters: // pToolBar - Points to a CXTPToolBar object to remove. //----------------------------------------------------------------------- void Remove(CXTPToolBar* pToolBar); //----------------------------------------------------------------------- // Summary: // Call this member to remove all toolbars. //----------------------------------------------------------------------- void RemoveAll(); // ----------------------------------------------------------------- // Summary: // Call this member to dock a toolbar to the specified dockbar. // Parameters: // pBar - Points to a CXTPToolBar object // lpRect - Position to dock. // pDockBar - Dock bar needed to be docked. // barPosition - Position to dock // Returns: // TRUE if the toolbar was successfully docked, FALSE if the bar // could not be docked. // ----------------------------------------------------------------- BOOL DockCommandBar(CXTPToolBar* pBar, LPRECT lpRect, CXTPDockBar* pDockBar); BOOL DockCommandBar(CXTPToolBar* pBar, XTPBarPosition barPosition); // //----------------------------------------------------------------------- // Summary: // Call this member to set the specified paint manager. // Parameters: // pPaintManager - Points to a CXTPPaintManager object //----------------------------------------------------------------------- void SetPaintManager(CXTPPaintManager* pPaintManager); //----------------------------------------------------------------------- // Summary: // Call this member to set the specified paint manager. // Parameters: // paintTheme - Visual theme to be set //----------------------------------------------------------------------- void SetTheme(XTPPaintTheme paintTheme); //----------------------------------------------------------------------- // Summary: // Call this member to set the specified image manager. // Parameters: // pImageManager - Points to a CXTPPaintManager object //----------------------------------------------------------------------- void SetImageManager(CXTPImageManager* pImageManager); //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the paint manager of the command // bars. // Returns: // A pointer to a CXTPPaintManager object //----------------------------------------------------------------------- CXTPPaintManager* GetPaintManager() const; //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the image manager of the command // bars. // Returns: // A pointer to a CXTPImageManager object //----------------------------------------------------------------------- CXTPImageManager* GetImageManager() const; //----------------------------------------------------------------------- // Summary: // Call this member to show/hide the toolbar. // Parameters: // nIndex - Index of the toolbar to show or hide. //----------------------------------------------------------------------- void ToggleVisible(int nIndex); //----------------------------------------------------------------------- // Summary: // Call this method to set customization file path // Parameters: // lpszFile - Path to customization file information // Remarks: // CommandBars can't store to registry customization information greater than 16kb, so it // creates file with user customization information. // If file not specified current directory will be used to save customization. // Example: // // if (GetAppDataFolder(strAppDataFolder)) // { // CreateDirectory(strAppDataFolder + _T("\\") + AfxGetApp()->m_pszAppName, NULL); // // // Set customization path as "\\Documents and Settings\\user\\Application Data\\CustomThemes\\CommandBars" // GetCommandBars()->SetCustomizationDataFileName(strAppDataFolder + _T("\\") + AfxGetApp()->m_pszAppName + _T("\\") + lpszProfileName); // } // //----------------------------------------------------------------------- void SetCustomizationDataFileName(LPCTSTR lpszFile); //----------------------------------------------------------------------- // Summary: // This method finds rebar of the frame // Returns: // CXTPReBar pointer if rebar was found; NULL otherwise. //----------------------------------------------------------------------- CXTPReBar* GetFrameReBar() const; //----------------------------------------------------------------------- // Summary: // Call this method to set default toolbar class // Parameters: // pToolBarClass - Runtime class of toolbars will be added. // Example: // // class CSystemToolBar : public CXTPToolBar // { // DECALRE_DYNCREATE(CSystemToolBar) // // .... // // } // // pCommandBars->SetToolBarClass(RUNTIME_CLASS(CSystemToolBar)); // // CXTPToolBar* pToolBar = pCommandBars->Add("New ToolBar", xtpBarTop); // ASSERT_KINDOF(CSystemToolBar, pToolBar); // // See Also: SetMenuBarClass, SetPopupBarClass //----------------------------------------------------------------------- static void AFX_CDECL SetToolBarClass(CRuntimeClass* pToolBarClass); //----------------------------------------------------------------------- // Summary: // Call this method to set default dockbar class // Parameters: // pDockBarClass - Runtime class of dockbar will be added. //----------------------------------------------------------------------- static void AFX_CDECL SetDockBarClass(CRuntimeClass* pDockBarClass); //----------------------------------------------------------------------- // Summary: // Call this method to set default menubar class // Parameters: // pMenuBarClass - Runtime class of menu will be added. //----------------------------------------------------------------------- static void AFX_CDECL SetMenuBarClass(CRuntimeClass* pMenuBarClass); //----------------------------------------------------------------------- // Summary: // Call this method to set default popupbar class // Parameters: // pPopupBarClass - Runtime class of popups will be added. //----------------------------------------------------------------------- static void AFX_CDECL SetPopupBarClass(CRuntimeClass* pPopupBarClass); //----------------------------------------------------------------------- // Summary: // Call this method to set default popup toolbar class // Parameters: // pPopupToolBarClass - Runtime class of popups will be added. //----------------------------------------------------------------------- static void AFX_CDECL SetPopupToolBarClass(CRuntimeClass* pPopupToolBarClass); //----------------------------------------------------------------------- // Summary: // Call this method to get tooltip context pointer. //----------------------------------------------------------------------- CXTPToolTipContext* GetToolTipContext() const; //----------------------------------------------------------------------- // Summary: // Call this member to find index of the specified toolbar // Parameters: // pToolBar - Pointer to a CXTPToolBar object. // Returns: // The index of the matching item. //----------------------------------------------------------------------- int FindIndex(CXTPToolBar* pToolBar) const; //----------------------------------------------------------------------- // Summary: // Call this member to close all popup windows //----------------------------------------------------------------------- void ClosePopups() const; //----------------------------------------------------------------------- // Summary: Call this member to get a reference to the statusbar object // Returns: Pointer to the CXTPStatusBar object //----------------------------------------------------------------------- CXTPStatusBar* GetStatusBar() const; protected: //----------------------------------------------------------------------- // Summary: // Call this member function to float a CXTPToolBar. // Parameters: // pBar - Pointer to a valid CXTPToolBar object. // Returns: // TRUE if the CXTPToolBar was successfully floated, otherwise FALSE. //----------------------------------------------------------------------- BOOL FloatCommandBar(CXTPToolBar* pBar); //----------------------------------------------------------------------- // Summary: // Call this member function to store state information about the // frame window's control bars in a CXTPDockState object. // Parameters: // state - Contains the current state of the frame window's control // bars upon return. //----------------------------------------------------------------------- void GetDockState(CXTPDockState& state); //----------------------------------------------------------------------- // Summary: // Call this member function to apply state information stored in a // CXTPDockState object to the frame window's control bars. // Parameters: // state - Apply the stored state to the frame window's control bars. //----------------------------------------------------------------------- void SetDockState(CXTPDockState& state); //----------------------------------------------------------------------- // Summary: // This method is called when new toolbar was added. // Parameters: // pToolBar - Pointer to new toolbar. //----------------------------------------------------------------------- virtual void OnToolBarAdded(CXTPToolBar* pToolBar); //----------------------------------------------------------------------- // Summary: // This method is called when new toolbar was removed // Parameters: // pToolBar - Pointer to toolbar was removed. //----------------------------------------------------------------------- virtual void OnToolBarRemoved(CXTPToolBar* pToolBar); //----------------------------------------------------------------------- // Summary: // This method is called to add custom toolbar. // Parameters: // lpcstrCaption - Title of toolbar. // nID - Toolbar id // bTearOffBar - TRUE if toolbar is tear-off // Returns: // A CXTPToolBar object if successful; otherwise NULL. // See Also: Add //----------------------------------------------------------------------- virtual CXTPToolBar* AddCustomBar(LPCTSTR lpcstrCaption, UINT nID, BOOL bTearOffBar = FALSE); public: //----------------------------------------------------------------------- // Summary: // This method is called when tracking mode of commandbar was changed // Parameters: // pCommandBar - Pointer to commandbar who's mode has changed // bMode - new mode the commandbar changed to. //----------------------------------------------------------------------- virtual void OnTrackingModeChanged(CXTPCommandBar* pCommandBar, int bMode); //----------------------------------------------------------------------- // Summary: // Call this method to get CXTPMouseManager pointer of command bars // Returns: // Pointer to CXTPMouseManager object // See Also: GetKeyboardManager //----------------------------------------------------------------------- CXTPMouseManager* GetMouseManager() const; //----------------------------------------------------------------------- // Summary: // Call this method to get GetKeyboardManager pointer of command bars // Returns: // Pointer to GetKeyboardManager object // See Also: CXTPMouseManager //----------------------------------------------------------------------- CXTPKeyboardManager* GetKeyboardManager() const; //----------------------------------------------------------------------- // Summary: // This method is called when user press Alt + char // Parameters: // chAccel - Character was pressed // Returns: // TRUE if command bars processed this character //----------------------------------------------------------------------- BOOL OnFrameAccel(UINT chAccel); //----------------------------------------------------------------------- // Summary: // Determines Help identifier of control under mouse cursor // Returns: // Identifier of control under mouse cursor // See Also: CXTPControl::SetHelpId //----------------------------------------------------------------------- int GetHelpTrackingId() const; //----------------------------------------------------------------------- // Summary: // This method is called to show keyboard cues of controls // Parameters: // bShow - TRUE to show keyboard cues //----------------------------------------------------------------------- void ShowKeyboardCues(BOOL bShow); //----------------------------------------------------------------------- // Summary: // Call this method to get actions list for command bars //----------------------------------------------------------------------- CXTPControlActions* GetActions() const; //----------------------------------------------------------------------- // Summary: // Call this method to let command bars automatically add actions for new commands //----------------------------------------------------------------------- void EnableActions(BOOL bEnableActions = TRUE); //----------------------------------------------------------------------- // Summary: // Determines if EnableActions method was called //----------------------------------------------------------------------- BOOL IsActionsEnabled() const; //----------------------------------------------------------------------- // Summary: // Call this method to add new action for specified id. // Parameters: // nId - Identifier of action to create //----------------------------------------------------------------------- CXTPControlAction* CreateAction(int nId); //----------------------------------------------------------------------- // Summary: // Call this method to find action for specified id. // Parameters: // nId - Identifier of action to find //----------------------------------------------------------------------- CXTPControlAction* FindAction(int nId) const; public: void EnableFrameTheme(BOOL bEnable = TRUE); void EnableToolbarComposition(BOOL bEnable = TRUE); CXTPCommandBarsFrameHook* GetFrameHook() const; BOOL IsDwmEnabled() const; protected: //{{AFX_CODEJOCK_PRIVATE // Implementation of Command Bars virtual BOOL SaveCommandBarList(CXTPPropExchange* pPX, CXTPCommandBarList* pCommandBarList); virtual BOOL LoadCommandBarList(CXTPPropExchange* pPX, CXTPCommandBarList* pCommandBarList); virtual void GenerateCommandBarList(CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam); virtual void RestoreCommandBarList(CXTPCommandBarList* pCommandBarList, BOOL bSilent = FALSE); void SerializeCommandBars(CArchive& ar); void SaveDockBarsState(LPCTSTR lpszProfileName); void LoadDockBarsState(LPCTSTR lpszProfileName); void SerializeDockBarsState(CXTPPropExchange* pPX); void _GetAddOrRemovePopup(CXTPToolBar* pToolBar, CXTPCommandBar* pExpandBar); void _LoadControlsPart(CFile& file, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam); BOOL GetControlsFileName(CString& strFileName, LPCTSTR lpszProfileName); CDocTemplate* FindDocTemplate(CMDIChildWnd* pChild); void DelayRedrawCommandBars(); int GetNextVisible(long nIndex, int nDirection) const; CXTPControl* FindAccel(CXTPCommandBar* pCommandBar, UINT chAccel, BOOL& bSelectOnly) const; CXTPControl* _GetNextControl(CXTPControls*& pControls, int nIndex) const; void IdleRecalcLayout(); void SetLayoutRTL(CWnd* pWnd, BOOL bRTLLayout); CString GetIsolatedFileName(const CString& strPrifileName); //}}AFX_CODEJOCK_PRIVATE public: CXTPControls* m_pDesignerControls; // Designer controls if used. BOOL m_bIgnoreShiftMenuKey; // if set menus will ignore Shift+Alt key combinations BOOL m_bDesignerMode; // TRUE if command bars in designer mode. //=========================================================================== // Summary: // Keyboard tips information //=========================================================================== struct KEYBOARDTIPS { CArray arr; //Keyboard tips collection CXTPCommandBar* pBar; // Owner of keyboard tips int nLevel; // Keyboard tip level (for RibbonBar) int nKey; // Keys was pressed already. } m_keyboardTips; //----------------------------------------------------------------------- // Summary: // This method is called to show keyboard tips for the commandbar. // Parameters: // pCommandBar - Owner of keyboard tips. // nLevel - Keyboard tip level (for RibbonBar). // See Also: HideKeyboardTips //----------------------------------------------------------------------- void ShowKeyboardTips(CXTPCommandBar* pCommandBar, int nLevel = 1); //------------------------------------------------------------------------- // Summary: // Removes all keyboard tips. // See Also: ShowKeyboardTips //------------------------------------------------------------------------- void HideKeyboardTips(); //------------------------------------------------------------------------- // Summary: // This method is called to create keyboard tips collection for commandbar. // Parameters: // pCommandBar - Owner of keyboard tips. // See Also: IsKeyboardTipsVisible //------------------------------------------------------------------------- virtual void CreateKeyboardTips(CXTPCommandBar* pCommandBar); protected: CXTPCustomizeDropSource* m_pDropSource; // Customize helper class. CXTPPaintManager* m_pPaintManager; // Paint manager. CXTPImageManager* m_pImageManager; // Image manager CCmdTarget* m_pDragSelected; // Customize control. BOOL m_bCustomizeMode; // Customize mode. BOOL m_bCustomizeAvail; // TRUE if customize available. int m_nDefaultMenuID; // Default menu resource. BOOL m_bEnableActions; // True if actions was enabled BOOL m_bQuickCustomizeMode; // TRUE if command bars in quick customization mode CString m_strControlsFileName; // File name to be used to store user customization. CXTPCommandBarsOptions* m_pOptions; // Command bars' options CXTPCommandBarsContextMenus* m_pContextMenus; // Context menu collection CArray m_arrBars; // Toolbars list. CXTPDockBar* m_pDocks[4]; // DockBars list CWnd* m_pFrame; // Parent frame of command bars CXTPToolTipContext* m_pToolTipContext; // Tooltip Context. mutable CXTPMouseManager* m_pMouseManager; // Mouse manager of command bars mutable CXTPKeyboardManager* m_pKeyboardManager; // Keyboard manager of command bars static CRuntimeClass* m_pToolBarClass; // Default toolbar class static CRuntimeClass* m_pMenuBarClass; // Default menubar class static CRuntimeClass* m_pPopupBarClass; // Default popupbar class static CRuntimeClass* m_pPopupToolBarClass; // Default popupbar class static CRuntimeClass* m_pDockBarClass; // Default dockbar class BOOL m_bKeyboardCuesVisible; // TRUE if menu underlines is currently visible CXTPShortcutManager* m_pShortcutManager; // Shortcut Manager of command bars. int m_nIDHelpTracking; // Selected control. CXTPControlActions* m_pActions; // Actions collection CXTPCommandBarsFrameHook* m_pFrameHook; private: BOOL m_bRecalcLayout; BOOL m_bUseKeyboardCues; BOOL m_bRightToLeft; BOOL m_bPreviewMode; private: DECLARE_DYNCREATE(CXTPCommandBars) friend class CXTPCommandBar; friend class CXTPToolBar; friend class CXTPDockContext; friend class CXTPDockState; friend class CXTPDockBar; friend class CXTPControlToolbars; friend class CXTPControl; friend class CCommandBarsCtrl; friend class CXTPCustomizeToolbarsPage; friend class CXTPPopupBar; friend class CXTPPopupToolBar; friend class CXTPMenuBar; friend class CXTPCommandBarsOptions; friend class CCommandBarsSite; friend class CXTPDialog; friend class CXTPRibbonBar; }; ////////////////////////////////////////////////////////////////////////// AFX_INLINE CWnd* CXTPCommandBars::GetSite() const { return m_pFrame; } AFX_INLINE CXTPDockBar* CXTPCommandBars::GetDockBar(XTPBarPosition barPosition) const { ASSERT(barPosition >= 0 && barPosition < 4); return barPosition >= 0 && barPosition < 4 ? m_pDocks[barPosition] : NULL; } AFX_INLINE int CXTPCommandBars::GetCount() const { return (int)m_arrBars.GetSize(); } AFX_INLINE CXTPCustomizeDropSource* CXTPCommandBars::GetDropSource() const { return m_pDropSource; } AFX_INLINE BOOL CXTPCommandBars::IsCustomizeAvail() const { return m_bCustomizeAvail; } AFX_INLINE void CXTPCommandBars::EnableCustomization(BOOL bCustomizeAvail) { m_bCustomizeAvail = bCustomizeAvail; } AFX_INLINE CXTPCommandBarsOptions* CXTPCommandBars::GetCommandBarsOptions() const { return m_pOptions; } AFX_INLINE void CXTPCommandBars::SetCustomizationDataFileName(LPCTSTR lpszFile) { m_strControlsFileName = lpszFile; } AFX_INLINE void CXTPCommandBars::SetToolBarClass(CRuntimeClass* pToolBarClass) { m_pToolBarClass = pToolBarClass; } AFX_INLINE void CXTPCommandBars::SetMenuBarClass(CRuntimeClass* pMenuBarClass) { m_pMenuBarClass = pMenuBarClass; } AFX_INLINE void CXTPCommandBars::SetDockBarClass(CRuntimeClass* pDockBarClass) { m_pDockBarClass = pDockBarClass; } AFX_INLINE void CXTPCommandBars::SetPopupBarClass(CRuntimeClass* pPopupBarClass) { m_pPopupBarClass = pPopupBarClass; } AFX_INLINE void CXTPCommandBars::SetPopupToolBarClass(CRuntimeClass* pPopupToolBarClass) { m_pPopupToolBarClass = pPopupToolBarClass; } AFX_INLINE int CXTPCommandBars::GetHelpTrackingId() const { return m_nIDHelpTracking; } AFX_INLINE CXTPControlActions* CXTPCommandBars::GetActions() const { return m_pActions; } AFX_INLINE BOOL CXTPCommandBars::IsActionsEnabled() const { return this == NULL ? FALSE : m_bEnableActions; } AFX_INLINE CXTPCommandBarsContextMenus* CXTPCommandBars::GetContextMenus() const { return m_pContextMenus; } AFX_INLINE CXTPCommandBarsFrameHook* CXTPCommandBars::GetFrameHook() const { return m_pFrameHook; } #endif //#if !defined(__XTPCOMMANDBARS_H__)