// XTPPopupBar.h : interface for the CXTPPopupBar 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(__XTPPOPUPBAR_H__) #define __XTPPOPUPBAR_H__ //}}AFX_CODEJOCK_PRIVATE #if _MSC_VER >= 1000 #pragma once #endif // _MSC_VER >= 1000 class CXTPControlPopup; class CXTPCommandBars; //=========================================================================== // Summary: // CXTPPopupBar is a CXTPCommandBar derived class. It represents submenu of menu bar. //=========================================================================== class _XTP_EXT_CLASS CXTPPopupBar : public CXTPCommandBar { //{{AFX_CODEJOCK_PRIVATE DECLARE_XTP_COMMANDBAR(CXTPPopupBar) //}}AFX_CODEJOCK_PRIVATE private: class CControlExpandButton; protected: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPPopupBar object //----------------------------------------------------------------------- CXTPPopupBar(); //----------------------------------------------------------------------- // Summary: // Destroys a CXTPPopupBar object, handles cleanup and deallocation //----------------------------------------------------------------------- ~CXTPPopupBar(); public: //----------------------------------------------------------------------- // Summary: // Creates a popup bar object. // Parameters: // pCommandBars - Points to a CXTPCommandBars object // Returns: // A pointer to a CXTPPopupBar object //----------------------------------------------------------------------- static CXTPPopupBar* AFX_CDECL CreatePopupBar(CXTPCommandBars* pCommandBars); public: //----------------------------------------------------------------------- // Summary: // This method adds the tear-off state to the popup bar. // Parameters: // lpszCaption - Caption of the tear-off toolbar. // nID - Identifier of the toolbar to be created. // nWidth - Width of the toolbar. //----------------------------------------------------------------------- void SetTearOffPopup(LPCTSTR lpszCaption, UINT nID, int nWidth = 400); //----------------------------------------------------------------------- // Summary: // Determines if Popupbar has tear-off state. // Parameters: // strCaption - Caption of the tear-off toolbar. // nID - Identifier of the toolbar to be created. // nWidth - Width of the toolbar. // Returns: // TRUE if tear-off; otherwise returns FALSE //----------------------------------------------------------------------- BOOL IsTearOffPopup(CString& strCaption, UINT& nID, int& nWidth); //------------------------------------------------------------------------- // Summary: // Call this member to determine if the popup menu is currently visible\popped up. // Returns: // TRUE is the popup menu is visible/displayed, FALSE if the popup menu // is currently hidden. //------------------------------------------------------------------------- virtual BOOL IsVisible() const; //----------------------------------------------------------------------- // Summary: // This method opens the popup bar. // Parameters: // xPos - Specifies the logical x coordinate of the popup bar // yPos - Specifies the logical y coordinate of the position. // rcExclude - Excluded area. // pControlPopup - Pointer to a CXTPControlPopup object // bSelectFirst - TRUE to select the first item. // Returns: // TRUE if successful; otherwise returns FALSE. //----------------------------------------------------------------------- BOOL Popup(int xPos, int yPos, LPCRECT rcExclude); BOOL Popup(CXTPControlPopup* pControlPopup, BOOL bSelectFirst = FALSE); // //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the control's popup. // Returns: // A pointer to a CXTPControlPopup object. //----------------------------------------------------------------------- CXTPControlPopup* GetControlPopup() const; //----------------------------------------------------------------------- // Summary: // This method expands the bar. //----------------------------------------------------------------------- void ExpandBar(); //----------------------------------------------------------------------- // Summary: // Call this member to destroy the window. // Returns: // TRUE if successful; otherwise returns FALSE. //----------------------------------------------------------------------- BOOL DestroyWindow(); //----------------------------------------------------------------------- // Summary: // Call this method to make popup bar looks like popup toolbar. // Parameters: // bToolBarType - TRUE to make bar as popup toolbar //----------------------------------------------------------------------- void SetPopupToolBar(BOOL bToolBarType); //----------------------------------------------------------------------- // Summary: // Sets the default menu item for the specified popup bar. // Parameters: // uItem - Identifier or position of the new default menu item or // - 1 for no default item. The meaning of this parameter // depends on the value of fByPos. // fByPos - Value specifying the meaning of uItem. If this parameter // is FALSE, uItem is a menu item identifier. Otherwise, // it is a menu item position. //----------------------------------------------------------------------- void SetDefaultItem(UINT uItem, BOOL fByPos = FALSE); //----------------------------------------------------------------------- // Summary: // Determines the default menu item on the specified popup bar. // Parameters: // gmdiFlags - Reserved. Should be NULL. // fByPos - Value specifying whether to retrieve the menu item's // identifier or its position. If this parameter is // FALSE, the identifier is returned. Otherwise, the // position is returned. // Returns: // If the function succeeds, the return value is the identifier // or position of the menu item. If the function fails, the return // value is - 1. //----------------------------------------------------------------------- UINT GetDefaultItem(UINT gmdiFlags, BOOL fByPos = FALSE); //----------------------------------------------------------------------- // Summary: // Call this method to determine if popup bar has double gripper. // Returns: // TRUE if popup bar has double gripper. //----------------------------------------------------------------------- BOOL IsDoubleGripper() const; //----------------------------------------------------------------------- // Summary: // Call this member to set double gripper for popup bar // Parameters: // bDoubleGripper - TRUE to set double gripper for popup bar //----------------------------------------------------------------------- void SetDoubleGripper(BOOL bDoubleGripper = TRUE); //----------------------------------------------------------------------- // Summary: // Call this member function to determine if the CommandBar is a // CXTPPopupBar. // Returns: // Returns TRUE if the CommandBar is a CXTPPopupBar, otherwise FALSE // See Also: CXTPCommandBar, CXTPPopupBar //----------------------------------------------------------------------- virtual BOOL IsPopupBar() const; //----------------------------------------------------------------------- // Summary: // Determines if popup bar was added as context menu. // Returns: // TRUE if popup bar is context menu // See Also: CXTPCommandBarsContextMenus //----------------------------------------------------------------------- BOOL IsContextMenu() const; //------------------------------------------------------------------------- // Summary: // Translates all messages in message queue. //------------------------------------------------------------------------- void PumpMessage(); //----------------------------------------------------------------------- // Summary: // This method is called to get the size of the command bar. // Parameters: // nLength - The requested dimension of the control bar, either horizontal or vertical, depending on dwMode. // dwMode - see CControlBar::CalcDynamicLayout for list of supported flags. // Returns: // Size of the command bar. //----------------------------------------------------------------------- virtual CSize CalcDynamicLayout(int nLength, DWORD dwMode); //----------------------------------------------------------------------- // Summary: // Creates the popup bar. // Returns: // TRUE if successful; otherwise returns FALSE //----------------------------------------------------------------------- virtual BOOL Create(); //----------------------------------------------------------------------- // Summary: // This method is called to calculate destination rectangle of popup bar. // Parameters: // ptPopup - Point to display popup bar. // sz - Size of popup bar. // Returns: // Rectangle where popup bar will be located. //----------------------------------------------------------------------- virtual CRect CalculatePopupRect(CPoint ptPopup, CSize sz); //----------------------------------------------------------------------- // Summary: Call this method to set popup direction // Input: dwPopupFlags - Direction of popup to open. See XTPPopupDirection enumerator // See Also: XTPPopupDirection //----------------------------------------------------------------------- void SetPopupFlags(DWORD dwPopupFlags); //----------------------------------------------------------------------- // 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. // See Also: IsTrackingMode. //----------------------------------------------------------------------- virtual BOOL SetTrackingMode(int bMode, BOOL bSelectFirst = TRUE, BOOL bKeyboard = FALSE); protected: //----------------------------------------------------------------------- // Summary: // Redraw the popup bar. //----------------------------------------------------------------------- virtual void DelayRedraw() { Redraw(); } //----------------------------------------------------------------------- // Summary: // Call this member to select the specified control. // Parameters: // nSelected - An integer index of the item to be selected. // bKeyboard - TRUE if the item was selected using the keyboard. // Returns: // TRUE if the method was successful; otherwise FALSE. //----------------------------------------------------------------------- virtual BOOL SetSelected(int nSelected, BOOL bKeyboard = FALSE); //----------------------------------------------------------------------- // Summary: // This method sets the PopupBar position. // Parameters: // sz - Size of the popup bar. //----------------------------------------------------------------------- void UpdateLocation(CSize sz); //----------------------------------------------------------------------- // Summary: // Update flags. //----------------------------------------------------------------------- virtual void UpdateFlags(); //----------------------------------------------------------------------- // Summary: // Update expanding state. //----------------------------------------------------------------------- void UpdateExpandingState(); //----------------------------------------------------------------------- // 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: // This method is called when the controls array is changed. //----------------------------------------------------------------------- virtual void OnControlsChanged(); //----------------------------------------------------------------------- // Summary: // This method is called to recalculate the command bar layout. //----------------------------------------------------------------------- virtual void OnRecalcLayout(); //----------------------------------------------------------------------- // Summary: // Call this member to retrieve the parent command bar // Returns: // A pointer to a CXTPCommandBar object //----------------------------------------------------------------------- CXTPCommandBar* GetParentCommandBar() const; //----------------------------------------------------------------------- // Summary: // Reads or writes this object from or to an archive. // Parameters: // pPX - A CXTPPropExchange object to serialize to or from. //---------------------------------------------------------------------- virtual void DoPropExchange(CXTPPropExchange* pPX); //----------------------------------------------------------------------- // Summary: // Call this method make a copy of the command bar. // Parameters: // pCommandBar - Command bar needed to be copied. // bRecursive - TRUE to copy recursively. //----------------------------------------------------------------------- virtual void Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive = FALSE); //----------------------------------------------------------------------- // Summary: // The framework calls this member function when a non-system key // is pressed. // Parameters: // nChar - Specifies the virtual key code of the given key. // lParam - Specifies additional message-dependent information. // Returns: // TRUE if key handled, otherwise returns FALSE //----------------------------------------------------------------------- virtual BOOL OnHookKeyDown(UINT nChar, LPARAM lParam); //----------------------------------------------------------------------- // Summary: // Updates rectangle to set position where popup bar become visible. // Parameters: // rc - CRect object specifying size of exclude area. // bVertical - TRUE if parent control is located vertically in bar. //----------------------------------------------------------------------- virtual void AdjustExcludeRect(CRect& rc, BOOL bVertical); public: //----------------------------------------------------------------------- // Summary: // Sets the toolbars borders. // Parameters: // rcBorders - Borders of the toolbar. //----------------------------------------------------------------------- void SetBorders(CRect rcBorders); //----------------------------------------------------------------------- // Summary: // Disables shadow use. //----------------------------------------------------------------------- void DisableShadow(); //----------------------------------------------------------------------- // Summary: Determines if control can be resized by user. // Returns: TRUE if the control can be resized, FALSE otherwise. //----------------------------------------------------------------------- BOOL IsResizable() const; //----------------------------------------------------------------------- // Summary: // This method is called to get borders margins of commandbar. // Returns: // Rectangle contains border margins. //----------------------------------------------------------------------- virtual CRect GetBorders(); protected: //{{AFX_CODEJOCK_PRIVATE DECLARE_MESSAGE_MAP() //{{AFX_MSG(CXTPPopupBar) afx_msg void OnMouseMove(UINT nFlags, CPoint point); afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message); BOOL OnNcActivate(BOOL bActive); afx_msg void OnTimer(UINT_PTR nIDEvent); afx_msg void OnLButtonDown(UINT nFlags, CPoint point); afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message); afx_msg BOOL OnNcCreate(LPCREATESTRUCT lpCreateStruct); LRESULT OnFloatStatus(WPARAM wParam, LPARAM); //}}AFX_MSG //}}AFX_CODEJOCK_PRIVATE protected: //------------------------------------------------------------------------- // Summary: Animates popup window //------------------------------------------------------------------------- virtual void Animate(); private: void AdjustScrolling(LPSIZE lpSize, BOOL bDown = FALSE, BOOL bInvalidate = FALSE); void TrackTearOff(); void TrackResize(); void RecalcSizeLayout(); void SwitchTearOffTracking(BOOL bShow, CPoint point); void _MakeSameWidth(int nStart, int nLast, int nWidth); BOOL _MouseInResizeGripper(const POINT& pt); XTPAnimationType GetAnimationType() const; public: static double m_dMaxWidthDivisor; // Maximum available width of popup protected: CXTPControlPopup* m_pControlPopup; // Control that popuped the bar. CPoint m_ptPopup; // Position of the bar. CRect m_rcExclude; // Excluded area. DWORD m_popupFlags; // Flags of the bar. BOOL m_bDynamicLayout; // TRUE if DynamicLayout routine executed. BOOL m_bCollapsed; // TRUE if popupbar is collapsed. BOOL m_bExpanded; // TRUE if popupbar is expanded. BOOL m_bExpanding; // TRUE if popupbar is expanding. BOOL m_bTearOffPopup; // TRUE if popupbar has tear-off option. CRect m_rcTearOffGripper; // Tear-off gripper position. CRect m_rcResizeGripper; // Resizable gripper position. BOOL m_bResizable; // TRUE to allow resize BOOL m_bTearOffSelected; // TRUE if gripper selected. UINT_PTR m_nTearOffTimer; // Tear-off timer. BOOL m_bTearOffTracking; // Tear-off tracking mode. CSize m_szTearOffBar; // Size of the bar. CXTPToolBar* m_pTearOffBar; // Tear-off toolbar pointer. CString m_strTearOffCaption; // Caption of the Tear-off toolbar. UINT m_nTearOffID; // ID of the Tear-off toolbar. int m_nTearOffWidth; // Width of the Tear-off toolbar. BOOL m_bShowShadow; // TRUE to show the shadow. CRect m_rcBorders; // Borders of the bar. BOOL m_bDoubleGripper; // TRUE if popup is state popup type BOOL m_bContextMenu; // TRUE if popup bar is context menu int m_nMaxHeight; // Maximum height the popup bar can become private: struct SCROLLINFO { struct BTNSCROLL { void Init(CWnd* pParent, UINT nID) { m_pParent = pParent; m_nID = nID; m_rc.SetRectEmpty(); m_nTimer = 0; } CRect m_rc; UINT m_nTimer; CWnd* m_pParent; UINT m_nID; void KillTimer() { m_pParent->KillTimer(m_nTimer); m_nTimer = 0;} void SetTimer() { if (m_nTimer == 0) m_nTimer = (UINT)m_pParent->SetTimer(m_nID, 80, 0); } BOOL OnMouseMove(CPoint point) { if (m_rc.PtInRect(point)) { SetTimer(); return TRUE; } else if (m_nTimer) KillTimer(); return FALSE; } }; BOOL bScroll; int nScrollFirst, nScrollLast; BTNSCROLL btnUp; BTNSCROLL btnDown; void Init(CWnd* pWnd, UINT nIDUp, UINT nIDDown) { btnUp.Init(pWnd, nIDUp); btnDown.Init(pWnd, nIDDown); bScroll = nScrollFirst = nScrollLast = 0; } } m_scrollInfo; private: BOOL Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext = NULL); friend class CControlExpandButton; friend class CXTPControlPopup; friend class CXTPCommandBars; friend class CXTPCommandBar; friend class CXTPCommandBarsContextMenus; }; //=========================================================================== // Summary: // CXTPPopupToolBar is a CXTPPopupBar derived class. //=========================================================================== class _XTP_EXT_CLASS CXTPPopupToolBar : public CXTPPopupBar { DECLARE_XTP_COMMANDBAR(CXTPPopupToolBar) //----------------------------------------------------------------------- // Summary: // Constructs a CXTPPopupToolBar object //----------------------------------------------------------------------- CXTPPopupToolBar(); public: //----------------------------------------------------------------------- // Summary: // Creates a popup toolbar object. // Parameters: // pCommandBars - Points to a CXTPCommandBars object // Returns: // A pointer to a CXTPPopupToolBar object //----------------------------------------------------------------------- static CXTPPopupToolBar* AFX_CDECL CreatePopupToolBar(CXTPCommandBars* pCommandBars); protected: //----------------------------------------------------------------------- // Summary: // This method is called to get the size of the command bar. // Parameters: // nLength - The requested dimension of the control bar, either horizontal or vertical, depending on dwMode. // dwMode - see CControlBar::CalcDynamicLayout for list of supported flags. // Returns: // Size of the command bar. //----------------------------------------------------------------------- CSize CalcDynamicLayout(int nLength, DWORD dwMode); }; ////////////////////////////////////////////////////////////////////////// AFX_INLINE void CXTPPopupBar::DisableShadow() { m_bShowShadow = FALSE; } AFX_INLINE void CXTPPopupBar::SetBorders(CRect rcBorders) { m_rcBorders = rcBorders; } AFX_INLINE BOOL CXTPPopupBar::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext) { return CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext); } AFX_INLINE BOOL CXTPPopupBar::IsDoubleGripper() const { return m_bDoubleGripper; } AFX_INLINE void CXTPPopupBar::SetDoubleGripper(BOOL bDoubleGripper /*= TRUE*/) { m_bDoubleGripper = bDoubleGripper; } AFX_INLINE CXTPControlPopup* CXTPPopupBar::GetControlPopup() const { return m_pControlPopup; } AFX_INLINE BOOL CXTPPopupBar::IsPopupBar() const { return TRUE; } AFX_INLINE BOOL CXTPPopupBar::IsContextMenu() const { return m_bContextMenu; } AFX_INLINE BOOL CXTPPopupBar::IsResizable() const { return m_bResizable; } AFX_INLINE void CXTPPopupBar::SetPopupFlags(DWORD dwPopupFlags) { m_popupFlags = dwPopupFlags; } #endif // #if !defined(__XTPPOPUPBAR_H__)