// XTPPopupControl.h: interface for the CXTPPopupControl class. // // This file is a part of the XTREME CONTROLS 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(_XTPPOPUPCONTROL_H__) #define _XTPPOPUPCONTROL_H__ //}}AFX_CODEJOCK_PRIVATE #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 class CXTPPopupItem; class CXTPPopupPaintManager; class CXTPImageManager; class CXTPImageManagerIcon; class CXTPMarkupContext; //----------------------------------------------------------------------- // Summary: // Enumeration used to determine the popup window theme in use // Example: // m_wndPopupControl.SetTheme(xtpPopupThemeOffice2000); // See Also: CXTPPopupControl::SetTheme, CXTPPopupControl::GetTheme // // //----------------------------------------------------------------------- enum XTPPopupPaintTheme { xtpPopupThemeOffice2000, // The theme like to a Office2000 xtpPopupThemeOfficeXP, // The theme like to a OfficeXP xtpPopupThemeOffice2003, // The theme like to a Office2003 xtpPopupThemeMSN, // The theme like to a MSN Messenger xtpPopupThemeResource, // The theme like to a Office2007 xtpPopupThemeCustom // The custom theme }; #define xtpPopupThemeOffice2007 xtpPopupThemeResource //----------------------------------------------------------------------- // Summary: // Location the popup control can get displayed. //----------------------------------------------------------------------- enum XTPPopupLocation { xtpPopupLocationNearTaskBar, // Displays in the bottom right of the screen right above the task bar. xtpPopupLocationBottomRight, // Displays in the bottom right of the screen. xtpPopupLocationCenter // Displays in the center of the screen. }; //----------------------------------------------------------------------- // Summary: // Enumeration used to determine the popup window animation in use // Example: // m_wndPopupControl.SetPopupAnimation(xtpPopupAnimationFade); // See Also: CXTPPopupControl::SetPopupAnimation, CXTPPopupControl::GetPopupAnimation // // //----------------------------------------------------------------------- enum XTPPopupAnimation { xtpPopupAnimationNone, // Animation is not used xtpPopupAnimationFade, // Fade method animation xtpPopupAnimationSlide, // Slide method animation xtpPopupAnimationUnfold // Unfold method animation }; //----------------------------------------------------------------------- // Summary: // Enumeration used to determine a current popup window state // Example: // // if (pControl->GetPopupState() == xtpPopupStateClosed) // { // EnableItems(TRUE); // } // // See Also: CXTPPopupControl::GetPopupState, CXTPPopupControl::SetPopupState // // //----------------------------------------------------------------------- enum XTPPopupState { xtpPopupStateClosed, // The popup window is closed xtpPopupStateExpanding, // The popup window is expanding xtpPopupStateShow, // The popup window is shown xtpPopupStateCollapsing // The popup window is collapsing }; //----------------------------------------------------------------------- // Summary: // The XTPWM_POPUPCONTROL_NOTIFY message is sent to the CXTPPopupControl owner window // whenever an action occurs within the CXTPPopupControl // Parameters: // nAction - Value of wParam specifies a Popup Control value that indicates the user's // request. Can be any of the values listed in the Remarks section. // Remarks: // nAction parameter can be one of the following: // * XTP_PCN_ITEMCLICK Indicates the user clicked on the popup control item. // * XTP_PCN_STATECHANGED Indicates the state of control changed. // Returns: // If the application is to process this message, the return value should be TRUE, otherwise the // return value is FALSE. // Example: // Here is an example of how an application would process the XTPWM_POPUPCONTROL_NOTIFY // message. // // // BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) // //{{AFX_MSG_MAP(CMainFrame) // ON_MESSAGE(XTPWM_POPUPCONTROL_NOTIFY, OnPopUpNotify) // //}}AFX_MSG_MAP // END_MESSAGE_MAP() // // LRESULT CMainFrame::OnPopUpNotify(WPARAM wParam, LPARAM lParam) // { // if (wParam == XTP_PCN_ITEMCLICK) // { // CXTPPopupItem* pItem = (CXTPPopupItem*)lParam; // ASSERT(pItem); // // m_wndPopupControl.Close(); // // if (pItem->GetID() == ID_GOTO_SITE) // { // ::ShellExecute(NULL, _T("open"), _T("http://www.codejock.com/"), NULL, NULL, SW_SHOW); // } // } // else if (wParam == XTP_PCN_STATECHANGED) // { // CXTPPopupControl* pControl = (CXTPPopupControl*)lParam; // ASSERT(pControl); // // if (pControl->GetPopupState() == xtpPopupStateClosed) // { // EnableItems(TRUE); // } // } // return TRUE; // } // // See Also: // XTP_PCN_ITEMCLICK, XTP_PCN_STATECHANGED, CXTPPopupControl //----------------------------------------------------------------------- const UINT XTPWM_POPUPCONTROL_NOTIFY = (WM_XTP_CONTROLS_BASE + 37); //----------------------------------------------------------------------- // Summary: // XTP_PCN_ITEMCLICK is used to indicate that the user clicked on a popup control item. // Remarks: // XTP_PCN_ITEMCLICK is sent in the XTPWM_POPUPCONTROL_NOTIFY message to the // owner window when the user has clicked on a popup control item. // Example: // See example of XTPWM_POPUPCONTROL_NOTIFY // See Also: // XTPWM_POPUPCONTROL_NOTIFY, XTP_PCN_STATECHANGED //----------------------------------------------------------------------- const UINT XTP_PCN_ITEMCLICK = 1; //----------------------------------------------------------------------- // Summary: // XTP_PCN_STATECHANGED is used to indicate that the state of popup control changed // Remarks: // XTP_PCN_STATECHANGED is sent in the XTPWM_POPUPCONTROL_NOTIFY message to the // owner window when the state of popup control changed. // It can be one of the following states: // * xtpPopupStateClosed Indicates the the popup window is closed // * xtpPopupStateExpanding Indicates the popup window is expanding // * xtpPopupStateShow Indicates the popup window is shown // * xtpPopupStateCollapsing Indicates the popup window is collapsing // Example: // See example of XTPWM_POPUPCONTROL_NOTIFY // See Also: // XTPWM_POPUPCONTROL_NOTIFY, XTP_PCN_ITEMCLICK //----------------------------------------------------------------------- const UINT XTP_PCN_STATECHANGED = 2; //----------------------------------------------------------------------- // Summary: // XTP_PCN_POSCHANGED is used to indicate that user move Popup control with mouse // See Also: // XTPWM_POPUPCONTROL_NOTIFY //----------------------------------------------------------------------- const UINT XTP_PCN_POSCHANGED = 3; //=========================================================================== // Summary: // CXTPPopupControl is a class for control of popup window //=========================================================================== class _XTP_EXT_CLASS CXTPPopupControl : public CWnd { protected: //----------------------------------------------------------------------- // Summary: // Popup state descriptor // See Also: CXTPPopupControl::m_stateTarget, CXTPPopupControl::m_stateCurrent //----------------------------------------------------------------------- struct POPUPSTATE { CRect rcPopup; // Popup position int nTransparency; // Popup transparency }; public: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPPopupControl object. //----------------------------------------------------------------------- CXTPPopupControl(BOOL bAutoDelete = FALSE); //----------------------------------------------------------------------- // Summary: // Destroys a CXTPPopupControl object, all handles cleanup and // deallocation. //----------------------------------------------------------------------- virtual ~CXTPPopupControl(); public: //----------------------------------------------------------------------- // Summary: // Call this member function to set the position of a popup // window. // Parameters: // ptPopup - a CPoint object containing XY location. //----------------------------------------------------------------------- void SetPopupPos(CPoint ptPopup); //----------------------------------------------------------------------- // Summary: // Call this member function to get the position of a popup // window. // Returns: // A CPoint object containing XY location. //----------------------------------------------------------------------- CPoint GetPopupPos() const; //----------------------------------------------------------------------- // Summary: // Call this member function to set the size of a popup window. // Parameters: // szPopup - A CSize object containing XY size. //----------------------------------------------------------------------- void SetPopupSize(CSize szPopup); //----------------------------------------------------------------------- // Summary: // Call this member function to get the size of a popup window. // Returns: // A CSize object containing XY size. //----------------------------------------------------------------------- CSize GetPopupSize() const; //----------------------------------------------------------------------- // Summary: // Call this member for create and starting expanding state // of a popup window // Parameters: // pParent - points to a CWnd object that represents the parent // window. // Returns: // TRUE if successful, otherwise returns FALSE. //----------------------------------------------------------------------- BOOL Show(CWnd* pParent); //----------------------------------------------------------------------- // Summary: Call this method to show modal popup control // Parameters: // pParent - points to a CWnd object that represents the parent // window. // Returns: // TRUE if successful, otherwise returns FALSE. //----------------------------------------------------------------------- BOOL ShowModal(CWnd* pParent); //----------------------------------------------------------------------- // Summary: // Call this member for starting collapsing state of a popup // window with the posterior destroy. //----------------------------------------------------------------------- void Hide(); //----------------------------------------------------------------------- // Summary: // Call this member to destroy a popup window. // Returns: // TRUE if successful, otherwise returns FALSE. //----------------------------------------------------------------------- BOOL Close(); //----------------------------------------------------------------------- // Summary: // Call this member function to set the transparency value of a // popup window. // Parameters: // bTransp - value of transparency (0...255). // If bTransp = 0 the popup window is full transparent, otherwise // if bTransp = 255 the popup window is full opaque. //----------------------------------------------------------------------- void SetTransparency(BYTE bTransp); //----------------------------------------------------------------------- // Summary: // Call this member function to get the transparency value a popup // window. // Returns: // Transparency value of a popup window. //----------------------------------------------------------------------- BYTE GetTransparency() const; //----------------------------------------------------------------------- // Summary: // Call this member function to set the value of show delay a // popup window. // Parameters: // dwShowDelay - value of show delay in milliseconds. //----------------------------------------------------------------------- void SetShowDelay(DWORD dwShowDelay); //----------------------------------------------------------------------- // Summary: // Call this member function to get the value of show delay a // popup window. // Returns: // Transparency value of show delay in milliseconds. //----------------------------------------------------------------------- DWORD GetShowDelay() const; //----------------------------------------------------------------------- // Summary: // Call this member function to set the value of animate delay // a popup window. // Parameters: // dwAnimateDelay - value of animate delay in milliseconds . //----------------------------------------------------------------------- void SetAnimateDelay(DWORD dwAnimateDelay); //----------------------------------------------------------------------- // Summary: // Call this member function to get the value of animate // delay a popup window. // Returns: // Transparency value of animate delay in milliseconds. //----------------------------------------------------------------------- DWORD GetAnimateDelay() const; //----------------------------------------------------------------------- // Summary: // Call this member function to set the popup animation method. // Parameters: // popupAnimation - method in use, see XTPPopupAnimation enum. //----------------------------------------------------------------------- void SetPopupAnimation(XTPPopupAnimation popupAnimation); //----------------------------------------------------------------------- // Summary: // Call this member function to set the default popup animation method. //----------------------------------------------------------------------- void SetPopupAnimation(); //----------------------------------------------------------------------- // Summary: // Call this member function to get the popup animation method. // Returns: // Method in use, see XTPPopupAnimation enum. //----------------------------------------------------------------------- XTPPopupAnimation GetPopupAnimation() const; //----------------------------------------------------------------------- // Summary: // Call this member function to get the current state of a popup // window. // Returns: // Current state, see XTPPopupState enum. //----------------------------------------------------------------------- XTPPopupState GetPopupState() const; //----------------------------------------------------------------------- // Summary: // Call this member function to set the paint manager or paint theme used // for drawing a popup window. // Parameters: // theme - theme of popup window drawing, see XTPPopupPaintTheme // enum. // pPaintManager - point of paint manager object. //----------------------------------------------------------------------- void SetTheme(XTPPopupPaintTheme theme); void SetTheme(CXTPPopupPaintManager* pPaintManager); // //----------------------------------------------------------------------- // Summary: // Call this member function to get the paint manager object used // for drawing a popup window. // Returns: // Point of paint manager object. //----------------------------------------------------------------------- CXTPPopupPaintManager* GetPaintManager() const; //----------------------------------------------------------------------- // Summary: // Call this member to get the theme that the popup window is // currently using. // Returns: // The currently used theme of the popup window drawing. // See Also: SetTheme, XTPPopupPaintTheme //----------------------------------------------------------------------- XTPPopupPaintTheme GetTheme() const; //----------------------------------------------------------------------- // Summary: // Call this member function to redraw all controlled items of a // popup window. //----------------------------------------------------------------------- void RedrawControl(); //----------------------------------------------------------------------- // Summary: // Call this member function to install new controlled item in // a popup window. // Parameters: // pItem - Point to CXTPPopupItem object which will be installed // in a popup window. // Returns: // Point to the installed CXTPPopupItem object. //----------------------------------------------------------------------- CXTPPopupItem* AddItem(CXTPPopupItem* pItem); //----------------------------------------------------------------------- // Summary: // Call this member function to remove all controlled items from // a popup window. //----------------------------------------------------------------------- void RemoveAllItems(); //----------------------------------------------------------------------- // Summary: // Call this member function to remove controlled item from // a popup window. // Parameters: // pItem - Point to CXTPPopupItem object which will be removed // nIndex - Index of item to remove from control //----------------------------------------------------------------------- void RemoveItem(CXTPPopupItem* pItem); void RemoveItem(int nIndex); // //----------------------------------------------------------------------- // Summary: // Call this member function to get count of controlled items // a popup window. // Returns: // Count of controlled items. //----------------------------------------------------------------------- int GetItemCount() const; //----------------------------------------------------------------------- // Summary: // Call this member function to get a controlled item on an index // Parameters: // nIndex - Index of a controlled item. // Returns: // Point to CXTPPopupItem object. //----------------------------------------------------------------------- CXTPPopupItem* GetItem(int nIndex) const; //----------------------------------------------------------------------- // Summary: // Call this member function to testing a point for controlled // items of a popup window. // Parameters: // pt - a CPoint object containing XY location for testing. // Returns: // Point to CXTPPopupItem object if test is successful, otherwise // returns NULL. //----------------------------------------------------------------------- CXTPPopupItem* HitTest(CPoint pt) const; //----------------------------------------------------------------------- // Summary: // Call this member to specify whether the user can click and drag // the popup window when it is displayed. // Parameters: // bAllowMove - TRUE to allow the user can click and drag the popup // window anywhere on the screen. // If FALSE, the popup window cannot be moved by the user. //----------------------------------------------------------------------- void AllowMove(BOOL bAllowMove); //----------------------------------------------------------------------- // Summary: // Call this member to set bitmap index for background. // Parameters: // nBackgroundBitmap - Index of bitmap in IamgeMnaager to set as background and region for control //----------------------------------------------------------------------- void SetBackgroundBitmap(int nBackgroundBitmap); //----------------------------------------------------------------------- // Summary: // Call this member to get bitmap index for background. // See Also: SetBackgroundBitmap //----------------------------------------------------------------------- int GetBackgroundBitmap() const; //----------------------------------------------------------------------- // Summary: // Call this member to let popup control delete self. // Parameters: // bAutoDelete - TRUE to delete control automatically after popup control will be closed. //----------------------------------------------------------------------- void SetAutoDelete(BOOL bAutoDelete); //----------------------------------------------------------------------- // Summary: // Call this member to set default popup location // Parameters: // nPopupLocation - Default Popup Location (Near TaskBar, BottomLeft or Center) // See Also: SetPopupPos //----------------------------------------------------------------------- void SetDefaultLocation(XTPPopupLocation nPopupLocation); BOOL GetSplashScreenMode() const; void SetSplashScreenMode(BOOL bSet); 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); //----------------------------------------------------------------------- // Summary: // Call this method to set new image manager. // Parameters: // pImageManager - Points to a CXTPImageManager object to be set // Example: // // CXTPImageManager* pImageManager = new CXTPImageManager(); // pImageManager->SetIcons(IDR_MAINFRAME); // m_wndPopupControl.SetImageManager(pImageManager); // // See Also: // GetImageManager //----------------------------------------------------------------------- void SetImageManager(CXTPImageManager* pImageManager); //----------------------------------------------------------------------- // Summary: // Call this method to get a pointer to the image manager of popup // control. // Returns: // Pointer to the image manager of popup control. // Remarks: // The image manager is used to hold all of the icons displayed in the // popup control. // See Also: // SetImageManager //----------------------------------------------------------------------- CXTPImageManager* GetImageManager() const; //----------------------------------------------------------------------- // Summary: Call this method to enable markup for Popup Control // Input: bEnableMarkup - TRUE to enable markup //----------------------------------------------------------------------- void EnableMarkup(BOOL bEnableMarkup); //------------------------------------------------------------------------- // Summary: // Returns markup context associated with Popup Control //------------------------------------------------------------------------- CXTPMarkupContext* GetMarkupContext() const; protected: //----------------------------------------------------------------------- // Summary: // Creates a popup window // Parameters: // pParentWnd - Pointer to the parent window. // Returns: // TRUE if successful, otherwise returns FALSE. //----------------------------------------------------------------------- virtual BOOL Create(CWnd* pParentWnd); //----------------------------------------------------------------------- // Summary: // This method is called when user click on controlled item // Parameters: // pItem - Item has been clicked. //----------------------------------------------------------------------- virtual void OnClick(CXTPPopupItem* pItem); //----------------------------------------------------------------------- // Summary: // This method is called to start expanding animation // Parameters: // bUpdateCurrent - TRUE to update current state. //----------------------------------------------------------------------- virtual void OnExpanding(BOOL bUpdateCurrent); //------------------------------------------------------------------------- // Summary: // This method is called to start collapsing animation //------------------------------------------------------------------------- virtual void OnCollapsing(); //------------------------------------------------------------------------- // Summary: // This method is called to show control //------------------------------------------------------------------------- virtual void OnShow(); //----------------------------------------------------------------------- // Summary: // This method is called to notify parent about action. // Parameters: // wParam - Occured action // lParam - Extended parameter. //----------------------------------------------------------------------- virtual void Notify(WPARAM wParam, LPARAM lParam); //----------------------------------------------------------------------- // Summary: // This method animates popup control // Parameters: // nStep - Current step of animation. //----------------------------------------------------------------------- void Animate(int nStep); //----------------------------------------------------------------------- // Summary: // Updates position in animation according current animation step // Parameters: // bInit - Initial step of animation. //----------------------------------------------------------------------- void UpdateState(BOOL bInit = FALSE); //----------------------------------------------------------------------- // Summary: // This method is called when current state of control changed. // Parameters: // popupState - Current state of control. //----------------------------------------------------------------------- void SetPopupState(XTPPopupState popupState); //----------------------------------------------------------------------- // Summary: // Updates current control transparency // Parameters: // bAlpha - Current alpha level of window // Returns: // TRUE if successful, otherwise returns FALSE. //----------------------------------------------------------------------- BOOL SetLayeredWindowAttributes(int bAlpha); //------------------------------------------------------------------------- // Summary: // Loop of control moving. //------------------------------------------------------------------------- void TrackMove(); protected: //{{AFX_CODEJOCK_PRIVATE DECLARE_MESSAGE_MAP() virtual void PostNcDestroy(); virtual BOOL OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult); //{{AFX_MSG(CXTPPopupControl) afx_msg void OnTimer(UINT_PTR nIDEvent); afx_msg BOOL OnEraseBkgnd(CDC* pDC); afx_msg void OnPaint(); afx_msg void OnLButtonDown(UINT nFlags, CPoint point); afx_msg void OnLButtonUp(UINT nFlags, CPoint point); afx_msg void OnCaptureChanged(CWnd* pWnd); afx_msg void OnMouseMove(UINT nFlags, CPoint point); afx_msg void OnMouseLeave(); afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message); afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message); //}}AFX_MSG //}}AFX_CODEJOCK_PRIVATE private: BOOL Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext = NULL); void UpdateBitmapRegion(); HRGN BitmapToRegion(CXTPImageManagerIcon* pIcon); void SetRegionAlphaLayer(CXTPImageManagerIcon* pIcon); protected: CXTPPopupPaintManager* m_pPaintManager; // point to CXTPPopupPaintManager object CArray m_arrItems; // array for controlled items CXTPPopupItem* m_pSelected; // point to selected item CXTPPopupItem* m_pPressed; // point to pressed item XTPPopupAnimation m_popupAnimation; // current animation method XTPPopupState m_popupState; // current popup state CSize m_szPopup; // current XY location of a popup window CPoint m_ptPopup; // current XY size of a popup window int m_nTransparency; // current value transparency of a popup window int m_nCurrentTransparency; // current transparency of a popup window UINT m_uShowDelay; // value of show delay of a popup window UINT m_uAnimationDelay; // value of animation delay of a popup window UINT m_nAnimationInterval; // value of animation interval of a popup window int m_nStep; // value of step animation of a popup window XTPPopupPaintTheme m_paintTheme; // Currently used theme. BOOL m_bAllowMove; // If TRUE, the user can click and drag the popup window anywhere on the screen. If FALSE, the popup window cannot be moved by the user. POPUPSTATE m_stateTarget; // Target descriptor POPUPSTATE m_stateCurrent; // Current descriptor CXTPImageManager* m_pImageManager; // Images of popup items. BOOL m_bRightToLeft; // Right-To-Left layout CXTPMarkupContext* m_pMarkupContext; // Assiciated Markup Context int m_nBackgroundBitmap; // Image index used as background of popup control BOOL m_bAutoDelete; // TRUE to delete popup after it will be closed XTPPopupLocation m_nPopupLocation; // Default locations for the popup control to display. HCURSOR m_hHandCursor; // The system hand cursor for hyperlink items. BOOL m_bSplashScreenMode; // TRUE to ignore mouse movement private: typedef BOOL (WINAPI *PFNSETLAYEREDWINDOWATTRIBUTES) (HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags); typedef BOOL(WINAPI* LPFNUPDATELAYEREDWINDOW) (HWND hwnd, HDC hdcDst, POINT *pptDst, SIZE *psize, HDC hdcSrc, POINT *pptSrc, COLORREF crKey, BLENDFUNCTION *pblend, DWORD dwFlags); PFNSETLAYEREDWINDOWATTRIBUTES m_pfnSetLayeredWindowAttributes; // point to Transparency proc in USER32.dll module LPFNUPDATELAYEREDWINDOW m_pfnUpdateLayeredWindow; BOOL m_bCapture; // capture flag of mouse event BOOL m_bLayered; friend class CXTPPopupItem; friend class CPopupControlCtrl; }; ///////////////////////////////////////////////////////////////////////////// AFX_INLINE BOOL CXTPPopupControl::GetSplashScreenMode() const { return m_bSplashScreenMode; } AFX_INLINE void CXTPPopupControl::SetSplashScreenMode(BOOL bSet) { m_bSplashScreenMode = bSet; } AFX_INLINE CXTPPopupPaintManager* CXTPPopupControl::GetPaintManager() const { return m_pPaintManager; } AFX_INLINE void CXTPPopupControl::SetPopupSize(CSize szPopup) { m_szPopup = szPopup; } AFX_INLINE CSize CXTPPopupControl::GetPopupSize() const { return m_szPopup; } AFX_INLINE void CXTPPopupControl::SetPopupPos(CPoint ptPopup) { m_ptPopup = ptPopup; } AFX_INLINE void CXTPPopupControl::SetShowDelay(DWORD dwShowDelay) { m_uShowDelay = dwShowDelay; } AFX_INLINE DWORD CXTPPopupControl::GetShowDelay() const { return m_uShowDelay; } AFX_INLINE void CXTPPopupControl::SetAnimateDelay(DWORD dwAnimateDelay) { m_uAnimationDelay = dwAnimateDelay; } AFX_INLINE DWORD CXTPPopupControl::GetAnimateDelay() const { return m_uAnimationDelay; } AFX_INLINE BYTE CXTPPopupControl::GetTransparency() const { return (BYTE)m_nTransparency; } AFX_INLINE void CXTPPopupControl::SetTransparency(BYTE nTransparency) { m_nTransparency = nTransparency; } AFX_INLINE void CXTPPopupControl::SetAutoDelete(BOOL bAutoDelete) { m_bAutoDelete = bAutoDelete; } AFX_INLINE XTPPopupAnimation CXTPPopupControl::GetPopupAnimation() const { return m_popupAnimation; } AFX_INLINE void CXTPPopupControl::SetPopupAnimation(XTPPopupAnimation popupAnimation) { m_popupAnimation = popupAnimation; } AFX_INLINE XTPPopupPaintTheme CXTPPopupControl::GetTheme() const { return m_paintTheme; } AFX_INLINE void CXTPPopupControl::AllowMove(BOOL bAllowMove) { m_bAllowMove = bAllowMove; } AFX_INLINE BOOL CXTPPopupControl::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 CXTPPopupControl::IsLayoutRTL() const { return m_bRightToLeft; } AFX_INLINE void CXTPPopupControl::SetBackgroundBitmap(int nBackgroundBitmap) { m_nBackgroundBitmap = nBackgroundBitmap; UpdateBitmapRegion(); } AFX_INLINE int CXTPPopupControl::GetBackgroundBitmap() const { return m_nBackgroundBitmap; } AFX_INLINE CXTPMarkupContext* CXTPPopupControl::GetMarkupContext() const { return m_pMarkupContext; } AFX_INLINE void CXTPPopupControl::SetDefaultLocation(XTPPopupLocation nPopupLocation) { m_nPopupLocation = nPopupLocation; } #endif // !defined(_XTPPOPUPCONTROL_H__)