/**
 * @file XTPFrameShadowManager.h
 *
 * @copyright
 * (c) 1998-2025 Codejock Software, All Rights Reserved.
 *
 * This source file is the property of Codejock Software and must not be
 * redistributed by any means without the explicit written permission of
 * Codejock Software.
 *
 * The use of this source code is governed by the terms and conditions specified
 * in the Toolkit Pro license agreement. Codejock Software grants you, as a
 * single software developer, the limited right to use this software on one
 * computer only.
 *
 * Contact Information:
 * support@codejock.com
 * http://www.codejock.com
 *
 */

/** @cond */
#if !defined(__XTPFRAMESHADOWMANAGER_H__)
#	define __XTPFRAMESHADOWMANAGER_H__
/** @endcond */

#	if _MSC_VER > 1000
#		pragma once
#	endif // _MSC_VER > 1000

#	include "Common/Base/Diagnostic/XTPDisableNoisyWarnings.h"

class CXTPFrameShadow;
class CXTPSimpleCriticalSection;
class CXTPFrameShadowManager;

/**
 * @brief Global Frame Shadow Manager flags.
 */
enum XTPFrameShadowManagerFlags
{
	/**
	 * Frame shadows disabled. When this flags is set the existing shadow made
	 * invisible and not resizeable (xtpFrameShadowsInvisible | xtpFrameShadowsNotResizeable
	 * get enabled automatically) but no new shadows will be created for new windows.
	 */
	xtpFrameShadowsDisabled = 1,

	/**
	 * Frame shadows are not visible but remain resizeable.
	 */
	xtpFrameShadowsInvisible = 2,

	/**
	 * Frame shadows cannot be used for resizing the owner windows.
	 */
	xtpFrameShadowsNotResizeable = 4,

	/**
	 * Frame shadows are automatically disabled for Terminal Services sessions,
	 * e.g. Remote Desktop Connection. When it's set and a Terminal Services
	 * session is detected all existing and new shadows will be made invisible
	 * and not resizeable (xtpFrameShadowsInvisible | xtpFrameShadowsNotResizeable).
	 * Once terminal session abandoning is detected those flags
	 * will get restored to their original values.
	 */
	xtpFrameShadowsDisabledInTSS = 8,

	/**
	 * Frame shadows are automatically invisible for Terminal Services sessions,
	 * e.g. Remote Desktop Connection, but remain resizealbe.
	 */
	xtpFrameShadowsInvisibleInTSS = 0x10
};

/**
 * @brief An interface for Frame Shadow Manager event listener.
 */
struct IXTPFrameShadowManagerEvents
{
	/**
	 * Handles object destruction
	 */
	virtual ~IXTPFrameShadowManagerEvents()
	{
	}

	/**
	 * @brief Invoked right after a shadow is enabled for a window.
	 * @param pManager Frame Shadow Manager pointer
	 * @param hwndOwner Shadow owner window handle
	 * @param pShadow Shadow pointer
	 */
	virtual void OnFrameShadowEnabled(CXTPFrameShadowManager* pManager, HWND hwndOwner,
									  CXTPFrameShadow* pShadow)
	{
		UNREFERENCED_PARAMETER(pManager);
		UNREFERENCED_PARAMETER(hwndOwner);
		UNREFERENCED_PARAMETER(pShadow);
	}

	/**
	 * @brief Invoked right before a shadow is disabled for a window.
	 * @param pManager Frame Shadow Manager pointer
	 * @param hwndOwner Shadow owner window handle
	 * @param pShadow Shadow pointer
	 */
	virtual void OnFrameShadowDisabled(CXTPFrameShadowManager* pManager, HWND hwndOwner,
									   CXTPFrameShadow* pShadow)
	{
		UNREFERENCED_PARAMETER(pManager);
		UNREFERENCED_PARAMETER(hwndOwner);
		UNREFERENCED_PARAMETER(pShadow);
	}

	/**
	 * @brief Invoked when flags are changed.
	 * @param pManager Frame Shadow Manager pointer
	 * @param nOldEffectiveFlags A set of old effective flags.
	 * @param nNewEffectiveFlags A set of new effective flags.
	 * @see XTPFrameShadowManagerFlags
	 */
	virtual void OnFlagsChanged(CXTPFrameShadowManager* pManager, int nOldEffectiveFlags,
								int nNewEffectiveFlags)
	{
		UNREFERENCED_PARAMETER(pManager);
		UNREFERENCED_PARAMETER(nOldEffectiveFlags);
		UNREFERENCED_PARAMETER(nNewEffectiveFlags);
	}
};

/**
 * @brief
 * Provides access to the global frame shdow manager instance.
 * @return
 * Global frame shadow instance pointer.
 */
_XTP_EXT_CLASS CXTPFrameShadowManager* AFX_CDECL XTPFrameShadowManager();

/**
 * @brief
 * Provides frame shadow management functionality.
 */
class _XTP_EXT_CLASS CXTPFrameShadowManager
	: public CXTPCmdTarget
	, public CXTPObservable<CXTPFrameShadowManager, IXTPFrameShadowManagerEvents>
{
	friend class CXTPSingleton<CXTPFrameShadowManager>;

	class CFrameShadowHook;
	friend class CFrameShadowHook;

	class CWtsEventListener;
	friend class CWtsEventListener;

	class CFrameShadowHooks;
	friend class CFrameShadowHooks;

	CXTPFrameShadowManager();

public:
	/** @cond */
	~CXTPFrameShadowManager();
	/** @endcond */

	/**
	 * @brief
	 * Determines if frame shadows are supported by the platform.
	 * @return
	 * TRUE if frame shadows are supported, otherwise FALSE.
	 */
	BOOL IsShadowSupported() const;

	/**
	 * @brief
	 * Obtains global frame shadow flags.
	 * @return
	 * Global frame shadow flags combination.
	 * @see XTPFrameShadowManagerFlags
	 */
	int GetFlags() const;

	/**
	 * @brief
	 * Sets global frame shadow flags. The previous value is overwritten.
	 * @param nFlags Global frame shadow flags combination.
	 * @see XTPFrameShadowManagerFlags
	 */
	void SetFlags(int nFlags);

	/**
	 * @brief
	 * Enables frame shadow for a window specified.
	 * @param pWnd A pointer to a non-child window for which frame shadow has to be enabled.
	 * @param crColor Optional. Frame shadow color. If not specified, default value is used.
	 * @param nOuterSize Optional. Frame shadow outer size. If not specified, default value is used.
	 * @param nInnerSize Optional. Frame shadow inner size. If not specified, default value is used.
	 * @param ptOffset Optional. Frame shadow offset. If not specified, default value is used.
	 * @param bTransparency Optional. Frame shadow transparency (0 fully transparent, 255 fully
	 * opaque).
	 * If not specified, default value is used.
	 * @return
	 * Shadow object pointer or NULL if failed.
	 * @see
	 * DisableShadow, IsShadowEnabled, GetShadow
	 */
	CXTPFrameShadow* EnableShadow(CWnd* pWnd, COLORREF crColor = (COLORREF)-1, UINT nOuterSize = 0,
								  UINT nInnerSize = 0, CPoint ptOffset = CPoint(0, 0),
								  BYTE bTransparency = 0);

	/**
	 * @brief
	 * Enables frame shadow for a window specified.
	 * @param hWnd A non-child window handle for which frame shadow has to be enabled.
	 * @param crColor Optional. Frame shadow color. If not specified, default value is used.
	 * @param nOuterSize Optional. Frame shadow outer size. If not specified, default value is used.
	 * @param nInnerSize Optional. Frame shadow inner size. If not specified, default value is used.
	 * @param ptOffset Optional. Frame shadow offset. If not specified, default value is used.
	 * @param bTransparency Optional. Frame shadow transparency (0 fully transparent, 255 fully
	 * opaque).
	 * If not specified, default value is used.
	 * @return
	 * Shadow object pointer or NULL if failed.
	 * @see
	 * DisableShadow, IsShadowEnabled, GetShadow
	 */
	CXTPFrameShadow* EnableShadow(HWND hWnd, COLORREF crColor = (COLORREF)-1, UINT nOuterSize = 0,
								  UINT nInnerSize = 0, CPoint ptOffset = CPoint(0, 0),
								  BYTE bTransparency = 0);

	/**
	 * @brief
	 * Disable a previsously enabled frame shadow for a window specified.
	 * @param hWnd A handle to a non-child window for which frame shadow has to be disabled.
	 * @see
	 * EnableShadow, IsShadowEnabled, GetShadow
	 */
	void DisableShadow(HWND hWnd);

	/**
	 * @brief
	 * Disable a previsously enabled frame shadow for a window specified.
	 * @param pWnd A pointer to a non-child window for which frame shadow has to be disabled.
	 * @see
	 * EnableShadow, IsShadowEnabled, GetShadow
	 */
	void DisableShadow(CWnd* pWnd);

	/**
	 * @brief
	 * Determines if a shadow is enabled for the window specified.
	 * @param pWnd A pointer to a window to check shadow for.
	 * @return
	 * TRUE if shadow is enabled for the window specified.
	 * @see
	 * EnableShadow, DisableShadow, GetShadow
	 */
	BOOL IsShadowEnabled(CWnd* pWnd) const;

	/**
	 * @brief
	 * Obtains shadow object pointer for a window specified.
	 * @param hWnd A handle to a window for which to obtain a shadow object pointer.
	 * @return
	 * Window's frame shadow object pointer or NULL if the window has no shadow enabled.
	 * @see
	 * EnableShadow, DisableShadow, IsShadowEnabled
	 */
	CXTPFrameShadow* GetShadow(HWND hWnd) const;

	/**
	 * @brief
	 * Obtains shadow object pointer for a window specified.
	 * @param pWnd A pointer to a window for which to obtain a shadow object pointer.
	 * @return
	 * Window's frame shadow object pointer or NULL if the window has no shadow enabled.
	 * @see
	 * EnableShadow, DisableShadow, IsShadowEnabled
	 */
	CXTPFrameShadow* GetShadow(CWnd* pWnd) const;

	/**
	 * @brief
	 * Obtains the position of the first shadow in the list of all enabled shadows.
	 * @return
	 * A position of the first enabled shadow in the internal list
	 * or NULL if not shadow is enabled.
	 * @see
	 * GetNextShadow
	 */
	POSITION GetFirstShadowPosition() const;

	/**
	 * @brief
	 * Obtains frame shadow pointer in the position specified and moves
	 * the position cursor to the next enabled shadow.
	 * @param pos Position to show.
	 * @return
	 * A pointer to the shadow at the position specified or NULL
	 * if the end of the list is reached.
	 * @see
	 * GetFirstShadowPosition
	 */
	CXTPFrameShadow* GetNextShadow(POSITION& pos) const;

	/**
	 * @brief
	 * Freezes/unfreezes updates on changing shadow settings, as a result
	 * shadow blinking is reduced.
	 * @param bFreeze If TRUE the update freeze counter is incremented. Otherwise
	 * the update freeze counter is decremented.
	 */
	void FreezeUpdates(BOOL bFreeze = TRUE);

	/**
	 * @brief
	 * Obtains a value of default outer size used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @return
	 * A default value.
	 * @see
	 * SetDefaultOuterSize, SetGlobalOuterSize
	 */
	UINT GetDefaultOuterSize() const;

	/**
	 * @brief
	 * Sets a value of default outer size used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @param nSize A new default value to be used.
	 * @see
	 * GetDefaultOuterSize, SetGlobalOuterSize
	 */
	void SetDefaultOuterSize(UINT nSize);

	/**
	 * @brief
	 * Sets a value of default outer size used for all shadows to be created
	 * if a default value is used in EnableShadow and applies the change for
	 * all enabled shadows.
	 * @param nSize A new value to be applied and used by default.
	 * @see
	 * GetDefaultOuterSize, SetDefaultOuterSize
	 */
	void SetGlobalOuterSize(UINT nSize);

	/**
	 * @brief
	 * Obtains a value of default inner size used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @return
	 * A default value.
	 * @see
	 * SetDefaultInnerSize, SetGlobalInnerSize
	 */
	UINT GetDefaultInnerSize() const;

	/**
	 * @brief
	 * Sets a value of default inner size used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @param nSize A new default value to be used.
	 * @see
	 * GetDefaultInnerSize, SetGlobalInnerSize
	 */
	void SetDefaultInnerSize(UINT nSize);

	/**
	 * @brief
	 * Sets a value of default inner size used for all shadows to be created
	 * if a default value is used in EnableShadow and applies the change for
	 * all enabled shadows.
	 * @param nSize A new value to be applied and used by default.
	 * @see
	 * GetDefaultInnerSize, SetDefaultInnerSize
	 */
	void SetGlobalInnerSize(UINT nSize);

	/**
	 * @brief
	 * Obtains a value of default shadow offset used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @return
	 * A default value.
	 * @see
	 * SetDefaultOffset, SetGlobalOffset
	 */
	CPoint GetDefaultOffset() const;

	/**
	 * @brief
	 * Sets a value of default shadow offset used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @param ptOffset A new default value to be used.
	 * @see
	 * GetDefaultOffset, SetGlobalOffset
	 */
	void SetDefaultOffset(CPoint ptOffset);

	/**
	 * @brief
	 * Sets a value of default shadow offset used for all shadows to be created
	 * if a default value is used in EnableShadow and applies the change for
	 * all enabled shadows.
	 * @param ptOffset A new value to be applied and used by default.
	 * @see
	 * GetDefaultOffset, SetDefaultOffset
	 */
	void SetGlobalOffset(CPoint ptOffset);

	/**
	 * @brief
	 * Obtains a value of default color used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @return
	 * A default value.
	 * @see
	 * SetDefaultColor, SetGlobalColor
	 */
	COLORREF GetDefaultColor() const;

	/**
	 * @brief
	 * Sets a value of default color used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @param crColor A new default value to be used.
	 * @see
	 * GetDefaultColor, SetGlobalColor
	 */
	void SetDefaultColor(COLORREF crColor);

	/**
	 * @brief
	 * Sets a value of default color used for all shadows to be created
	 * if a default value is used in EnableShadow and applies the change for
	 * all enabled shadows.
	 * @param crColor A new value to be applied and used by default.
	 * @see
	 * GetDefaultColor, SetDefaultColor
	 */
	void SetGlobalColor(COLORREF crColor);

	/**
	 * @brief
	 * Obtains a value of default transparency used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @return
	 * A default value. 0 means a fully transparent shadow, 255 means fully opaque.
	 * @see
	 * SetDefaultTransparency, SetGlobalTransparency
	 */
	BYTE GetDefaultTransparency() const;

	/**
	 * @brief
	 * Sets a value of default transparency used for all shadows to be created
	 * if a default value is used in EnableShadow.
	 * @param bTransparency A new default value to be used. 0 means a fully transparent shadow, 255
	 * means fully opaque.
	 * @see
	 * GetDefaultTransparency, SetGlobalTransparency
	 */
	void SetDefaultTransparency(BYTE bTransparency);

	/**
	 * @brief
	 * Sets a value of default trasparency used for all shadows to be created
	 * if a default value is used in EnableShadow and applies the change for
	 * all enabled shadows.
	 * @param bTransparency A new default value to be used. 0 means a fully transparent shadow, 255
	 * means fully opaque.
	 * @see
	 * GetDefaultTransparency, SetDefaultTransparency
	 */
	void SetGlobalTransparency(BYTE bTransparency);

	/**
	 * @brief
	 * Obtains default blending options used for all shadows to be created
	 * if a default value is used in EnableShadow. Refer to CXTPFrameShadow
	 * documentation for further details.
	 * @param pFactors Optionals. If not NULL, should be a pointer to an array of
	 * the number of elements equal to the returned value.
	 * @param pPositions Optionals. If not NULL, should be a pointer to an array of
	 * the number of elements equal to the returned value.
	 * @return
	 * A number of factors and positions used for blending.
	 * @see
	 * SetDefaultBlendingOptions, SetGlobalBlendingOptions, CXTPFrameShadow
	 */
	UINT GetDefaultBlendingOptions(OUT OPTIONAL float* pFactors,
								   OUT OPTIONAL float* pPositions) const;

	/**
	 * @brief
	 * Sets default blending options used for all shadows to be created
	 * if a default value is used in EnableShadow. Refer to CXTPFrameShadow
	 * documentation for further details.
	 * @param nCount The number of blending factors and positions.
	 * @param pFactors A pointer to an array of nCount elements. Ignored if nCount = 0.
	 * @param pPositions A pointer to an array of nCount elements. Ignored if nCount = 0.
	 * @see
	 * GetDefaultBlendingOptions, SetGlobalBlendingOptions, CXTPFrameShadow
	 */
	void SetDefaultBlendingOptions(UINT nCount, const float* pFactors, const float* pPositions);

	/**
	 * @brief
	 * Sets default blending options used for all shadows to be created
	 * if a default value is used in EnableShadow and applies the change for
	 * all enabled shadows. Refer to CXTPFrameShadow
	 * documentation for further details.
	 * @param nCount The number of blending factors and positions.
	 * @param pFactors A pointer to an array of nCount elements. Ignored if nCount = 0.
	 * @param pPositions A pointer to an array of nCount elements. Ignored if nCount = 0.
	 * @see
	 * GetDefaultBlendingOptions, SetDefaultBlendingOptions, CXTPFrameShadow
	 */
	void SetGlobalBlendingOptions(UINT nCount, const float* pFactors, const float* pPositions);

	/**
	 * @brief
	 * Obtains default owner clipping for new shadows.
	 * @details
	 * By default owner clipping is enabled in order to reduce flickering
	 * and improve rendering speed in slow environments. Disabling owner
	 * clipping may be necessary for owner windows that non-rectangular shape
	 * as the clipping box is always rectangular.
	 * @returns TRUE if clipping is enabled.
	 * @see
	 * SetGlobalClipOwner
	 */
	BOOL GetDefaultClipOwner() const;

	/**
	 * @brief
	 * Sets default owner clipping for new shadows.
	 * @param bClipOwner TRUE to enable clipping.
	 * @details
	 * By default owner clipping is enabled in order to reduce flickering
	 * and improve rendering speed in slow environments. Disabling owner
	 * clipping may be necessary for owner windows that non-rectangular shape
	 * as the clipping box is always rectangular.
	 * @see
	 * SetGlobalClipOwner
	 */
	void SetDefaultClipOwner(BOOL bClipOwner);

	/**
	 * @brief
	 * Sets owner clipping for all shadows.
	 * @param bClipOwner TRUE to enable clipping.
	 * @details
	 * By default owner clipping is enabled in order to reduce flickering
	 * and improve rendering speed in slow environments. Disabling owner
	 * clipping may be necessary for owner windows that non-rectangular shape
	 * as the clipping box is always rectangular.
	 * @see
	 * GetDefaultClipOwner, SetDefaultClipOwner
	 */
	void SetGlobalClipOwner(BOOL bClipOwner);

protected:
	virtual void OnFinalRelease();

private:
	void SetShadowThreadMessageHook(CXTPFrameShadow* pShadow, BOOL bSet = TRUE);
	void OnHookMessage(UINT nHook, HWND hWnd, UINT nCode, WPARAM& wParam, LPARAM& lParam,
					   LRESULT& lResult);
	void UpdateAllShadows(BOOL bRedraw = FALSE);
	void SetInTerminalServiceSession(BOOL bInTSS, BOOL bUpdate = FALSE);
	void UpdateTerminalSessionFlags();

#	ifdef _XTP_ACTIVEX
	/** @cond */

	DECLARE_DISPATCH_MAP()
	DECLARE_INTERFACE_MAP()

	DECLARE_OLETYPELIB_EX(CXTPFrameShadowManager);

	afx_msg long OleGetFlags();
	afx_msg void OleSetFlags(long flags);
	afx_msg long OleGetDefaultOuterSize();
	afx_msg void OleSetDefaultOuterSize(long size);
	afx_msg long OleGetDefaultInnerSize();
	afx_msg void OleSetDefaultInnerSize(long size);
	afx_msg OLE_XSIZE_PIXELS OleGetDefaultOffsetX();
	afx_msg void OleSetDefaultOffsetX(OLE_XSIZE_PIXELS offset);
	afx_msg OLE_YSIZE_PIXELS OleGetDefaultOffsetY();
	afx_msg void OleSetDefaultOffsetY(OLE_YSIZE_PIXELS offset);
	afx_msg OLE_COLOR OleGetDefaultColor();
	afx_msg void OleSetDefaultColor(OLE_COLOR color);
	afx_msg short OleGetDefaultTransparency();
	afx_msg void OleSetDefaultTransparency(short val);
	afx_msg BOOL OleGetDefaultClipOwner();
	afx_msg void OleSetDefaultClipOwner(BOOL bClip);
	afx_msg VARIANT OleGetDefaultBlendingFactors();
	afx_msg VARIANT OleGetDefaultBlendingPositions();
	afx_msg void OleDisableShadow(OLE_HANDLE hWnd);
	afx_msg BOOL OleIsShadowEnabled(OLE_HANDLE hWnd);
	afx_msg void OleFreezeUpdates(VARIANT_BOOL bFreeze);
	afx_msg void OleSetGlobalOuterSize(long size);
	afx_msg void OleSetGlobalInnerSize(long size);
	afx_msg void OleSetGlobalOffset(OLE_XSIZE_PIXELS offsetX, OLE_YSIZE_PIXELS offsetY);
	afx_msg void OleSetGlobalColor(OLE_COLOR color);
	afx_msg void OleSetDefaultBlendingOptions(const VARIANT& factors, const VARIANT& positions);
	afx_msg void OleSetGlobalBlendingOptions(const VARIANT& factors, const VARIANT& positions);
	afx_msg void OleSetGlobalTransparency(short val);
	afx_msg void OleSetGlobalClipOwner(BOOL bClip);
	afx_msg LPDISPATCH OleEnableShadow(OLE_HANDLE hWnd, OLE_HANDLE color, long outerSize,
									   long innerSize, OLE_XSIZE_PIXELS offsetX = 0,
									   OLE_YSIZE_PIXELS offsetY = 0, short transparancy = 0);
	afx_msg LPDISPATCH OleGetShadow(OLE_HANDLE hWnd);
	afx_msg LPDISPATCH OleGetFrameShadows();
	/** @endcond */
#	endif

private:
	int m_nFlags, m_nEffectiveFlags;
	BOOL m_bInTerminalServiceSession;
	CWtsEventListener* m_pWtsEventListener;

	CMap<HWND, HWND&, CXTPFrameShadow*, CXTPFrameShadow*&> m_mapWnd;
	UINT m_nDefaultOuterSize;
	UINT m_nDefaultInnerSize;
	CPoint m_ptDefaultOffset;
	COLORREF m_crDefaultColor;
	BYTE m_bDefaultTransparency;
	BOOL m_bDefaultClipOwner;
	CXTPSimpleCriticalSection* m_pGuard;
	BOOL m_bInUpdateAllShadows;

	struct DefaultBlendingOptions
	{
		CArray<float, const float&> Factors;
		CArray<float, const float&> Positions;
	} m_DefaultBlendingOptions;

	CMap<DWORD, DWORD&, CFrameShadowHooks*, CFrameShadowHooks*&> m_mapHooks;
};

#	ifdef _XTP_ACTIVEX
/** @cond */

/////////////////////////////////////////////////////////////////////////////
// CFrameShadows command target

class CFrameShadows : public CXTPCmdTarget
{
	DECLARE_DYNCREATE(CFrameShadows)

	CFrameShadows(); // protected constructor used by dynamic creation

	// Attributes
public:
	// Operations
public:
	// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CFrameShadows)
public:
	virtual void OnFinalRelease();
	//}}AFX_VIRTUAL

	// Implementation
protected:
	virtual ~CFrameShadows();

	// Generated message map functions
	//{{AFX_MSG(CFrameShadows)
	// NOTE - the ClassWizard will add and remove member functions here.
	//}}AFX_MSG

	DECLARE_MESSAGE_MAP()

	// Generated OLE dispatch map functions
	//{{AFX_DISPATCH(CFrameShadows)
	DECLARE_ENUM_VARIANTLIST(CFrameShadows)
	//}}AFX_DISPATCH
	DECLARE_DISPATCH_MAP()
	DECLARE_INTERFACE_MAP()
	DECLARE_OLETYPELIB_EX(CFrameShadows);
};

/** @endcond */
#	endif
/** @cond */
AFX_INLINE int CXTPFrameShadowManager::GetFlags() const
{
	return m_nEffectiveFlags;
}

AFX_INLINE BOOL CXTPFrameShadowManager::IsShadowEnabled(CWnd* pWnd) const
{
	return NULL != GetShadow(pWnd);
}

AFX_INLINE UINT CXTPFrameShadowManager::GetDefaultOuterSize() const
{
	return m_nDefaultOuterSize;
}

AFX_INLINE void CXTPFrameShadowManager::SetDefaultOuterSize(UINT nSize)
{
	m_nDefaultOuterSize = nSize;
}

AFX_INLINE UINT CXTPFrameShadowManager::GetDefaultInnerSize() const
{
	return m_nDefaultInnerSize;
}

AFX_INLINE void CXTPFrameShadowManager::SetDefaultInnerSize(UINT nSize)
{
	m_nDefaultInnerSize = nSize;
}

AFX_INLINE CPoint CXTPFrameShadowManager::GetDefaultOffset() const
{
	return m_ptDefaultOffset;
}

AFX_INLINE void CXTPFrameShadowManager::SetDefaultOffset(CPoint ptOffset)
{
	m_ptDefaultOffset = ptOffset;
}

AFX_INLINE COLORREF CXTPFrameShadowManager::GetDefaultColor() const
{
	return m_crDefaultColor;
}

AFX_INLINE void CXTPFrameShadowManager::SetDefaultColor(COLORREF crColor)
{
	m_crDefaultColor = crColor;
}

AFX_INLINE BYTE CXTPFrameShadowManager::GetDefaultTransparency() const
{
	return m_bDefaultTransparency;
}

AFX_INLINE void CXTPFrameShadowManager::SetDefaultTransparency(BYTE bTransparency)
{
	m_bDefaultTransparency = bTransparency;
}

AFX_INLINE BOOL CXTPFrameShadowManager::GetDefaultClipOwner() const
{
	return m_bDefaultClipOwner;
}

AFX_INLINE void CXTPFrameShadowManager::SetDefaultClipOwner(BOOL bClipOwner)
{
	m_bDefaultClipOwner = bClipOwner;
}
/** @endcond */
#	include "Common/Base/Diagnostic/XTPEnableNoisyWarnings.h"
/** @cond */
#endif // !defined(__XTPFRAMESHADOWMANAGER_H__)
/** @endcond */